home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume2 / dungeon / part07 < prev    next >
Encoding:
Internet Message Format  |  1987-09-02  |  52.9 KB

  1. Path: uunet!seismo!ut-sally!im4u!rutgers!mit-eddie!uw-beaver!tektronix!tekgen!tekred!games-request
  2. From: games-request@tekred.TEK.COM
  3. Newsgroups: comp.sources.games
  4. Subject: v02i040:  dungeon - game of adventure, Part07/14
  5. Message-ID: <1563@tekred.TEK.COM>
  6. Date: 1 Sep 87 20:38:26 GMT
  7. Sender: billr@tekred.TEK.COM
  8. Lines: 2239
  9. Approved: billr@tekred.TEK.COM
  10.  
  11. Submitted by: Bill Randle <games-request@tekred.TEK.COM>
  12. Comp.sources.games: Volume 2, Issue 40
  13. Archive-name: dungeon/Part07
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then unpack
  17. # it by saving it into a file and typing "sh file".  To overwrite existing
  18. # files, type "sh file -c".  You can also feed this as standard input via
  19. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  20. # will see the following message at the end:
  21. #        "End of archive 7 (of 14)."
  22. # Contents:  Makefile PDP.doc advers.h ballop.F cinit.c cio.c cspeak.c
  23. #   curxt.h debug.h decode.c dso1.F dso3.F dso4.F dso5.F dso6.F dso7.F
  24. #   dungeon.sh exits.h files.h flags.h gamestate.h io.h lightp.F
  25. #   listen.c mindex.h oindex.h parser.h puzzle.h rflag.h rooms.h
  26. #   rtim.c screen.h state.h villians.h vocab.h xpars.h xsrch.h
  27. # Wrapped by billr@tekred on Tue Apr 21 10:24:39 1987
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f Makefile -a "${1}" != "-c" ; then 
  30.   echo shar: Will not over-write existing file \"Makefile\"
  31. else
  32. echo shar: Extracting \"Makefile\" \(1818 characters\)
  33. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  34. X# Makefile for creating dungeon
  35. X# Edit BIN DDIR and FFLAGS suitable for your system
  36. X.c.o:
  37. X    cc -c $(CFLAGS) $*.c
  38. X.F.o:
  39. X    f77 -c $(FFLAGS) $*.F
  40. X
  41. XCFLAGS = -O # -i
  42. X#
  43. X# f77 compiler flags for Vax (and other large address machines)
  44. X#
  45. XFFLAGS = -O -q # -Ddebug
  46. X# f77 compiler flags for pdp (64K split I/D)
  47. X#FFLAGS = -O -q -I2 -L1 -i -DPDP # -Ddebug
  48. X
  49. X# Directory path for main program - default /usr/games
  50. XBIN = /usr/games
  51. X# Directory path for data files - default is /usr/games/lib/dunlib
  52. XDDIR = \'/usr/games/lib/dunlib
  53. XDCDIR =\"/usr/games/lib/dunlib
  54. X# Directory path for man page - default /usr/manl/man6
  55. XMDIR = /usr/manl/man6
  56. X# userid for wizard - allows invoking game debugging tool - default 0
  57. XWIZDEF = -DWIZARDID=20
  58. X
  59. XOBJS =  actors.o ballop.o clockr.o demons.o\
  60. X    dgame.o dinit.o dmain.o dso1.o dso2.o\
  61. X    dso3.o dso4.o dso5.o dso6.o dso7.o\
  62. X    dsub.o dverb1.o dverb2.o gdt.o lightp.o\
  63. X    nobjs.o np.o np1.o np2.o np3.o nrooms.o objcts.o\
  64. X    rooms.o rtim.o sobjs.o sverbs.o verbs.o villns.o
  65. X
  66. XPDPOBJS = cinit.o cio.o lex.o
  67. XLISTEN = listen.o
  68. XSPEAK = cspeak.o speak.o
  69. X
  70. Xvax:    dungeon dtext.dat
  71. Xpdp:    dungpdp speak listen dtext.dat
  72. X
  73. Xdungeon: $(OBJS)
  74. X    f77 -s -o dungeon $(OBJS)
  75. X
  76. Xdungpdp: $(OBJS) $(PDPOBJS)
  77. X    f77 -i -s -o dungpdp $(OBJS) $(PDPOBJS)
  78. X
  79. Xspeak:    $(SPEAK)
  80. X    f77 -i -s -o speak $(SPEAK)
  81. X    
  82. Xspeak.o: speak.F
  83. X    f77 $(FFLAGS) -DDDIR=$(DDIR) -c speak.F
  84. X
  85. Xlisten:    $(LISTEN)
  86. X    cc $(CFLAGS) -o listen $(LISTEN)
  87. X
  88. Xlisten.o: listen.c
  89. X    cc $(CFLAGS) -DCINDEXFILE=$(DCDIR)/dindx.dat\" -c listen.c
  90. X
  91. Xdinit.o: dinit.F
  92. X    f77 $(FFLAGS) -DDDIR=$(DDIR) $(WIZDEF) -c dinit.F
  93. X
  94. Xinstall-vax: vax
  95. X    cp dungeon $(BIN)
  96. X    -mkdir $(DDIR)
  97. X    cp dindx.dat dtext.dat $(DDIR)
  98. X    cp dungeon.6 $(MDIR)/dungeon.6
  99. X
  100. Xinstall-pdp: pdp
  101. X    cp dungeon.sh $(BIN)
  102. X    -mkdir $(DDIR)
  103. X    cp dindx.dat dtext.dat rtext.dat dungpdp $(DDIR)
  104. X    cp dungeon.6 $(MDIR)/dungeon.6
  105. X
  106. Xdtext.dat: 
  107. X    ./maketxt.sh
  108. X
  109. END_OF_Makefile
  110. if test 1818 -ne `wc -c <Makefile`; then
  111.     echo shar: \"Makefile\" unpacked with wrong size!
  112. fi
  113. # end of overwriting check
  114. fi
  115. if test -f PDP.doc -a "${1}" != "-c" ; then 
  116.   echo shar: Will not over-write existing file \"PDP.doc\"
  117. else
  118. echo shar: Extracting \"PDP.doc\" \(2922 characters\)
  119. sed "s/^X//" >PDP.doc <<'END_OF_PDP.doc'
  120. XThe implementation of dungeon on unix systems
  121. XRandy Dietrich         17 Nov 1981
  122. X
  123. XWhen we set out to get dungeon running on unix we figured
  124. Xit wouldn't be too big a problem.  After all a fortran
  125. Xcompiler (F77) existed and with relatively little problem
  126. Xmanaged to get everything to compile.  
  127. XThen the Zorkmids hit the volcano.
  128. XWe thought that a program which would run in 28k on an
  129. XRSX system would have fit just fine in 64k, especially
  130. Xwith seperate i & d.  We did not realize just how hostile 
  131. Xunix is to FORTRAN programs.
  132. XThe first link indicated about 130 k (text only) was needed
  133. Xfor the whole game (Ieeeeee).  Recompiling with short (I2)
  134. Xintegers brought this down to about 100k.  Throwing out
  135. Xthe game debug package (9k) and the save and restore code (3k)
  136. Xgot us to within 20k.  
  137. XAt this point we discovered that the fortran library that
  138. Xwas being used was about 25k (A HA !!).  If we could just 
  139. Xeliminate that we would be in business.  A great game with
  140. Xno I/O !!  further work allowed us to write the I/O in C
  141. Xwith the bulk of the game using only standard input and output.
  142. XThe initialization and message printing were "moved out"
  143. Xinto seperate processes and the whole mess piped together.
  144. Xit is a real kludge but seems to work (mostly).
  145. X
  146. XThe Input process is called 'listen'.  It first reads the init
  147. Xfile and shoves it in the pipe and then switches to pass
  148. Xkeyboard input to the main game.  This keeps the main program
  149. Xfrom having to read anything but 'standard input'.
  150. X
  151. XThe output process is currently called 'speak'.
  152. Xthis process does the lookup in the file 'dtext.dat' and
  153. Xsends out the messages that give dungeon it's flavor.  This
  154. Xprocess also passes clear text from the main program to
  155. Xallow the output of other messages for such things as the
  156. Xecho room, puzzle room, and score.  These functions
  157. Xwere also 'moved out' so the main program would not have
  158. Xto access any disc files.
  159. X
  160. XThe main program is sandwitched between listen and speak.
  161. XIt really does the work of the game.  I/O is handled
  162. Xthorugh C routines in 'cio.c'. this keeps any fortran
  163. XI/O from being used and calling in the whole #$%@ fortran
  164. Xlibrary.
  165. X
  166. XThe current lash-up does save or restore but not both.  
  167. XIt is going to take a while to work in as we are out of room
  168. Xin the main program and will have to re-write something
  169. Xto make it all fit.  I guess we will just have to play
  170. Xwithout being able to cheat for a while.
  171. X
  172. XRestores are done by initializing the game with a second argument
  173. X(some day the file name) of 'r'.  This causes the init process 
  174. Xto send a 'R' down down the pipe followed by the restore data.
  175. Xnormally the init process ends with a '?'.  The trailing '?'
  176. Xwill follow the restore data.
  177. X
  178. XSaves are done from within the game.  The game sends a 's'
  179. Xdown the pipe to signal the speak process to do a save opperation.
  180. XThe save data then goes down the pipe followed by 'e' to
  181. Xsignal the end of data.  The save data is 'dungeon.sav'.
  182. END_OF_PDP.doc
  183. if test 2922 -ne `wc -c <PDP.doc`; then
  184.     echo shar: \"PDP.doc\" unpacked with wrong size!
  185. fi
  186. # end of overwriting check
  187. fi
  188. if test -f advers.h -a "${1}" != "-c" ; then 
  189.   echo shar: Will not over-write existing file \"advers.h\"
  190. else
  191. echo shar: Extracting \"advers.h\" \(217 characters\)
  192. sed "s/^X//" >advers.h <<'END_OF_advers.h'
  193. XC
  194. XC ADVENTURERS
  195. XC
  196. X    COMMON /ADVS/ ALNT,AROOM(4),ASCORE(4),AVEHIC(4),
  197. X&        AOBJ(4),AACTIO(4),ASTREN(4),AFLAG(4)
  198. X    INTEGER EQA(4,7)
  199. X    EQUIVALENCE (AROOM, EQA)
  200. XC
  201. X    COMMON /AFLAGS/ ASTAG
  202. XC
  203. X    COMMON /AINDEX/ PLAYER,AROBOT,AMASTR
  204. END_OF_advers.h
  205. if test 217 -ne `wc -c <advers.h`; then
  206.     echo shar: \"advers.h\" unpacked with wrong size!
  207. fi
  208. # end of overwriting check
  209. fi
  210. if test -f ballop.F -a "${1}" != "-c" ; then 
  211.   echo shar: Will not over-write existing file \"ballop.F\"
  212. else
  213. echo shar: Extracting \"ballop.F\" \(2153 characters\)
  214. sed "s/^X//" >ballop.F <<'END_OF_ballop.F'
  215. XC BALLOP-    BALLOON FUNCTION
  216. XC
  217. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  218. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  219. XC WRITTEN BY R. M. SUPNIK
  220. XC
  221. XC DECLARATIONS
  222. XC
  223. X    LOGICAL FUNCTION BALLOP(ARG)
  224. X    IMPLICIT INTEGER (A-Z)
  225. X    LOGICAL FINDXT,QEMPTY
  226. X#include "parser.h"
  227. X#include "gamestate.h"
  228. X#include "state.h"
  229. X#include "rooms.h"
  230. X#include "rflag.h"
  231. X#include "curxt.h"
  232. X#include "xpars.h"
  233. X#include "objects.h"
  234. X#include "oflags.h"
  235. X#include "oindex.h"
  236. X#include "clock.h"
  237. X
  238. X#include "verbs.h"
  239. X#include "flags.h"
  240. XC BALLOP, PAGE 2
  241. XC
  242. X    BALLOP=.TRUE.
  243. XC                        !ASSUME WINS.
  244. X    IF(ARG.NE.2) GO TO 200
  245. XC                        !READOUT?
  246. X    IF(PRSA.NE.LOOKW) GO TO 10
  247. XC                        !ONLY PROCESS LOOK.
  248. X    IF(BINFF.NE.0) GO TO 50
  249. XC                        !INFLATED?
  250. X    CALL RSPEAK(543)
  251. XC                        !NO.
  252. X    GO TO 100
  253. X50    CALL RSPSUB(544,ODESC2(BINFF))
  254. XC                        !YES.
  255. X100    IF(BTIEF.NE.0) CALL RSPEAK(545)
  256. XC                        !HOOKED?
  257. X    RETURN
  258. XC
  259. X200    IF(ARG.NE.1) GO TO 500
  260. XC                        !READIN?
  261. X    IF(PRSA.NE.WALKW) GO TO 300
  262. XC                        !WALK?
  263. X    IF(FINDXT(PRSO,HERE)) GO TO 250
  264. XC                        !VALID EXIT?
  265. X    CALL RSPEAK(546)
  266. XC                        !NO, JOKE.
  267. X    RETURN
  268. XC
  269. X250    IF(BTIEF.EQ.0) GO TO 275
  270. XC                        !TIED UP?
  271. X    CALL RSPEAK(547)
  272. XC                        !YES, JOKE.
  273. X    RETURN
  274. XC
  275. X275    IF(XTYPE.NE.XNORM) GO TO 10
  276. XC                        !NORMAL EXIT?
  277. X    IF(and(RFLAG(XROOM1),RMUNG).EQ.0) BLOC=XROOM1
  278. X10    BALLOP=.FALSE.
  279. X    RETURN
  280. XC
  281. X300    IF((PRSA.NE.TAKEW).OR.(PRSO.NE.BINFF)) GO TO 350
  282. X    CALL RSPSUB(548,ODESC2(BINFF))
  283. XC                        !RECEP CONT TOO HOT.
  284. X    RETURN
  285. XC
  286. X350    IF((PRSA.NE.PUTW).OR.(PRSI.NE.RECEP).OR.QEMPTY(RECEP))
  287. X&        GO TO 10
  288. X    CALL RSPEAK(549)
  289. X    RETURN
  290. XC
  291. X500    IF((PRSA.NE.UNBOAW).OR.(and(RFLAG(HERE),RLAND).EQ.0))
  292. X&        GO TO 600
  293. X    IF(BINFF.NE.0) CTICK(CEVBAL)=3
  294. XC                        !HE GOT OUT, START BALLOON.
  295. X    GO TO 10
  296. XC
  297. X600    IF((PRSA.NE.BURNW).OR.(OCAN(PRSO).NE.RECEP)) GO TO 700
  298. X    CALL RSPSUB(550,ODESC2(PRSO))
  299. XC                        !LIGHT FIRE IN RECEP.
  300. X    CTICK(CEVBRN)=OSIZE(PRSO)*20
  301. X    OFLAG1(PRSO)=or(OFLAG1(PRSO),
  302. X&        and((ONBT+FLAMBT+LITEBT), not(TAKEBT+READBT)))
  303. X    IF(BINFF.NE.0) RETURN
  304. X    IF(.NOT.BLABF) CALL NEWSTA(BLABE,0,0,BALLO,0)
  305. X    BLABF=.TRUE.
  306. X    BINFF=PRSO
  307. X    CTICK(CEVBAL)=3
  308. X    CALL RSPEAK(551)
  309. X    RETURN
  310. XC
  311. X700    IF((PRSA.EQ.UNBOAW).AND.(BINFF.NE.0).AND.
  312. X&        (and(RFLAG(HERE),RLAND).NE.0))
  313. X&        CTICK(CEVBAL)=3
  314. X    GO TO 10
  315. XC
  316. X    END
  317. END_OF_ballop.F
  318. if test 2153 -ne `wc -c <ballop.F`; then
  319.     echo shar: \"ballop.F\" unpacked with wrong size!
  320. fi
  321. # end of overwriting check
  322. fi
  323. if test -f cinit.c -a "${1}" != "-c" ; then 
  324.   echo shar: Will not over-write existing file \"cinit.c\"
  325. else
  326. echo shar: Extracting \"cinit.c\" \(940 characters\)
  327. sed "s/^X//" >cinit.c <<'END_OF_cinit.c'
  328. X#include <stdio.h>
  329. X
  330. X
  331. X/*    read one integer from the open file */
  332. Xintrd_(valptr)
  333. X
  334. Xint *valptr;
  335. X{
  336. X    scanf("%d",valptr);
  337. X    while((getchar() != '\n'));
  338. X    return;
  339. X}
  340. X
  341. X/*    read an array from the open file */
  342. Xaryrd_(cntptr,aryptr)
  343. X
  344. Xint *cntptr,*aryptr[];
  345. X{
  346. X    int i;
  347. X
  348. X    for(i = *cntptr; i > 0;--i,++aryptr)
  349. X        scanf("%d",aryptr);
  350. X    while((getchar() != '\n'));
  351. X    return;
  352. X}
  353. X
  354. X/* get a logical value */
  355. Xlogrd_(ptr)
  356. Xint *ptr;
  357. X{
  358. Xstatic char byte;
  359. X
  360. X    *ptr = 0;
  361. X    while((byte = getchar()) != '\n'){
  362. X        if ((byte == 'T') || (byte == 't'))
  363. X            *ptr = 1;
  364. X    }
  365. X    return;
  366. X}
  367. X
  368. X
  369. X/* wait for end of init flag */
  370. Xinitnd_()
  371. X{
  372. X    static int chr;
  373. X
  374. X    while ((chr = getchar()) != '?'){    /* wait for end flag */
  375. X        if (chr == 'R')        /* check for restore flag */
  376. X            rstrgm_();    /* call restore routine  */
  377. X    }
  378. X    return;
  379. X}
  380. X
  381. X/*    write an array to the open pipe */
  382. Xarywt_(cntptr,aryptr)
  383. X
  384. Xint *cntptr,*aryptr[];
  385. X{
  386. X    static int i;
  387. X
  388. X    for(i = *cntptr; i > 0;--i,++aryptr)
  389. X        printf("%d\n",*aryptr);
  390. X    return;
  391. X}
  392. X
  393. END_OF_cinit.c
  394. if test 940 -ne `wc -c <cinit.c`; then
  395.     echo shar: \"cinit.c\" unpacked with wrong size!
  396. fi
  397. # end of overwriting check
  398. fi
  399. if test -f cio.c -a "${1}" != "-c" ; then 
  400.   echo shar: Will not over-write existing file \"cio.c\"
  401. else
  402. echo shar: Extracting \"cio.c\" \(2551 characters\)
  403. sed "s/^X//" >cio.c <<'END_OF_cio.c'
  404. X/* these are c routines to handle the pdp dungeon i/o */
  405. X#include <stdio.h>
  406. X
  407. X/*    send arguments to message printing process */
  408. Xrspsb3_(arg1,arg2,arg3)
  409. X
  410. Xint *arg1,*arg2,*arg3;
  411. X{
  412. X    printf("n%d %d %d\n",*arg1,*arg2,*arg3);
  413. X    fflush(stdout);
  414. X    return;    
  415. X}
  416. X
  417. X/* print for puzzle room */
  418. Xpuzout_(p)
  419. X
  420. Xchar *p;
  421. X{
  422. X
  423. Xprintf("       |%c%c %c%c %c%c|\n",p[0],p[0],p[1],p[1],p[2],p[2]);
  424. Xprintf("  WEST |%c%c .. %c%c| EAST\n",p[3],p[3],p[4],p[4]);
  425. Xprintf("       |%c%c %c%c %c%c|\n",p[5],p[5],p[6],p[6],p[7],p[7]);
  426. Xfflush(stdout);
  427. Xreturn;
  428. X}
  429. X
  430. X/* output general string (echo room) */
  431. Xoutstr_(ptr,len)
  432. X
  433. Xint  *len;
  434. Xchar *ptr[];
  435. X{
  436. X    printf("%.*s\n",*len,ptr);
  437. X    fflush(stdout);
  438. X    return;
  439. X}
  440. X
  441. X
  442. X/* print a prompt */
  443. Xprompt_()
  444. X{
  445. X    printf(" > ~");
  446. X    fflush(stdout);
  447. X    return;
  448. X}
  449. X
  450. X/* terminate the game */
  451. Xexit_()
  452. X{
  453. X    fprintf(stderr,"The game is over\n");
  454. X    exit(0);
  455. X}
  456. X
  457. X/*    read a character */
  458. Xrdchr_(cptr)
  459. X
  460. Xchar *cptr;
  461. X{
  462. Xstatic int ch;
  463. X
  464. X    if((ch = getchar()) == EOF){
  465. X        fprintf(stderr,"EOF on input\n");
  466. X        exit_();
  467. X    }
  468. X    else     *cptr = ch;
  469. X    return;
  470. X}
  471. X
  472. X/* read a line from std input */
  473. Xrdlin_(sptr,cntptr)
  474. X
  475. Xint *cntptr;
  476. Xchar *sptr;
  477. X{
  478. Xstatic int chr;
  479. X    *cntptr = 0;
  480. X    while ((chr = getchar()) != EOF){
  481. X        if((chr >= 97) && (chr <= 122))    /* convert to uc */
  482. X            chr -= 32;
  483. X        if (chr == 10 ){         /* quit if newline */
  484. X            *sptr++ = '\0';
  485. X            return;
  486. X        }
  487. X        if ((chr == 32) && (*cntptr == 0))  /* rm lead blank */
  488. X            continue;
  489. X        if (*cntptr >= 78)
  490. X            continue;
  491. X        *sptr++ = chr;
  492. X        (*cntptr)++;
  493. X    }
  494. X    fprintf(stderr,"EOF on input\n");
  495. X    exit_();
  496. X}
  497. X
  498. X/*    print cure time */
  499. Xcured_(time)
  500. X
  501. Xint *time;
  502. X{
  503. X    printf(" You will be cured in %d moves\n",*time);
  504. X    fflush(stdout);
  505. X    return;
  506. X}
  507. X
  508. X/* print the score */
  509. Xpscore_(score,max,moves)
  510. X
  511. Xint *score, *max, *moves;
  512. X{
  513. Xprintf(" Your current score is %d out of %d points in %d moves.\n",*score, *max, *moves);
  514. X    fflush(stdout);
  515. X    return;
  516. X}
  517. X
  518. X/* BUG-- REPORT FATAL SYSTEM ERROR 
  519. XC
  520. XC CALLED BY--
  521. XC
  522. XC    CALL BUG(NO,PAR)
  523. XC
  524. XC      note: return if DBGFLG set is not implemented
  525. XC*/
  526. Xbug_(a,b)
  527. X
  528. Xint *a,*b;
  529. X{
  530. X    fprintf(stderr,"Program error %d ; Parameter %d\n",*a,*b);
  531. X    exit(0);
  532. X}
  533. X
  534. X
  535. X/* send restore message  */
  536. Xrestor_()
  537. X{
  538. X    printf(" Restore by starting with 'dungeon r'\n");
  539. X    return;
  540. X}
  541. X
  542. X/* password output */
  543. Xvoice_(sp1, sp2)
  544. X
  545. Xchar *sp1, *sp2;
  546. X{
  547. X    printf(" A Hollow voice replies: %6.6s %6.6s\n", sp1, sp2);
  548. X    return;
  549. X}
  550. X
  551. X/* print version */
  552. Xprvers_(v1, v2, v3)
  553. X
  554. Xint *v1, *v2;
  555. Xchar *v3;
  556. X{
  557. X    printf(" V%1d.%2d%c\n", *v1, *v2, *v3);
  558. X    return;
  559. X}
  560. X
  561. X/* dummy stub for game debugger */
  562. Xnogdt_()
  563. X{
  564. X    /* debugger deleted to save room */
  565. X    printf(" Sorry, no debugger available in this version.\n");
  566. X    return;
  567. X}
  568. END_OF_cio.c
  569. if test 2551 -ne `wc -c <cio.c`; then
  570.     echo shar: \"cio.c\" unpacked with wrong size!
  571. fi
  572. # end of overwriting check
  573. fi
  574. if test -f cspeak.c -a "${1}" != "-c" ; then 
  575.   echo shar: Will not over-write existing file \"cspeak.c\"
  576. else
  577. echo shar: Extracting \"cspeak.c\" \(1188 characters\)
  578. sed "s/^X//" >cspeak.c <<'END_OF_cspeak.c'
  579. X#include <stdio.h>
  580. X
  581. X/*     routine to sort out input stream  */
  582. X/*    first character determines destination of the following data
  583. X        n - get arguments for 'rspeak'
  584. X        s - put data on dungeon save file until 'e' is received
  585. X         else - pass text to screen    */
  586. X
  587. Xinprd_(pa,pb,pc)
  588. X
  589. Xint *pa, *pb, *pc;
  590. X{
  591. Xint chr;
  592. X
  593. X    (*pa)=(*pb)=(*pc)=0;
  594. X
  595. X    while((chr = getchar()) != EOF) {
  596. X        if (chr == '\n')
  597. X            continue;
  598. X        switch (chr) {
  599. X
  600. X            case 'n':    /* get args for rspeak  */
  601. X                if (scanf("%d%d%d",pa,pb,pc) > 0)
  602. X                    return;
  603. X                else
  604. X                    printf("Speak input error\n");
  605. X                break;
  606. X    
  607. X            case 's':    /* send save data to file  */
  608. X                wrtsave();
  609. X                break;
  610. X
  611. X            default:
  612. X                putchar(chr);
  613. X                break;
  614. X    
  615. X        }
  616. X        /* send text to screen  */
  617. X        while((chr = getchar()) != EOF){
  618. X            if (chr == '~')
  619. X                break;
  620. X            putchar(chr);
  621. X            if (chr == '\n')
  622. X                break;
  623. X        }
  624. X    }
  625. X
  626. X    /* terminate process */
  627. X    printf("Goodbye ... GASP\n");
  628. X    exit(0);
  629. X}
  630. X
  631. X/*    write a save file  */
  632. X
  633. Xwrtsave()
  634. X{
  635. X    FILE *savptr, *fopen();
  636. X    char chr;
  637. X
  638. X    savptr = fopen("dungeon.sav","w");
  639. X
  640. X    while ((chr = getchar()) != EOF) {
  641. X        if (chr == 'e')    {        /* check for end char */
  642. X            fclose(savptr);
  643. X            return;
  644. X        }
  645. X        putc(chr,savptr);
  646. X    }
  647. X    printf("EOF during save\n");
  648. X    exit(0);
  649. X}
  650. END_OF_cspeak.c
  651. if test 1188 -ne `wc -c <cspeak.c`; then
  652.     echo shar: \"cspeak.c\" unpacked with wrong size!
  653. fi
  654. # end of overwriting check
  655. fi
  656. if test -f curxt.h -a "${1}" != "-c" ; then 
  657.   echo shar: Will not over-write existing file \"curxt.h\"
  658. else
  659. echo shar: Extracting \"curxt.h\" \(94 characters\)
  660. sed "s/^X//" >curxt.h <<'END_OF_curxt.h'
  661. XC
  662. XC CURRENT EXITS
  663. XC
  664. X    COMMON /CURXT/ XTYPE,XROOM1,XSTRNG,XACTIO,XOBJ
  665. X    EQUIVALENCE (XFLAG,XOBJ)
  666. END_OF_curxt.h
  667. if test 94 -ne `wc -c <curxt.h`; then
  668.     echo shar: \"curxt.h\" unpacked with wrong size!
  669. fi
  670. # end of overwriting check
  671. fi
  672. if test -f debug.h -a "${1}" != "-c" ; then 
  673.   echo shar: Will not over-write existing file \"debug.h\"
  674. else
  675. echo shar: Extracting \"debug.h\" \(80 characters\)
  676. sed "s/^X//" >debug.h <<'END_OF_debug.h'
  677. XC
  678. X    COMMON /DEBUG/ DBGFLG,PRSFLG,GDTFLG
  679. X#ifdef debug
  680. X    LOGICAL DFLAG
  681. X#endif debug
  682. END_OF_debug.h
  683. if test 80 -ne `wc -c <debug.h`; then
  684.     echo shar: \"debug.h\" unpacked with wrong size!
  685. fi
  686. # end of overwriting check
  687. fi
  688. if test -f decode.c -a "${1}" != "-c" ; then 
  689.   echo shar: Will not over-write existing file \"decode.c\"
  690. else
  691. echo shar: Extracting \"decode.c\" \(462 characters\)
  692. sed "s/^X//" >decode.c <<'END_OF_decode.c'
  693. X/*
  694. X * Decode dtext.dat file into readable ASCII.
  695. X * John Gilmore (hoptoad!gnu), December 1986
  696. X */
  697. X#include <stdio.h>
  698. X#define STRLEN 74
  699. Xchar string[STRLEN+1];
  700. Xint recno = 0;
  701. X
  702. Xmain() {
  703. X    unsigned char byte, byte2;
  704. X    int i;
  705. X
  706. X    while (1) {
  707. X        recno++;
  708. X        byte = getchar();
  709. X        byte2 = getchar();
  710. X        if (1 != fread (string, STRLEN, 1, stdin)) exit(0);
  711. X        for (i = 1; i <= STRLEN; i++) 
  712. X            string[i-1] ^= (recno&31)+i;
  713. X        printf("%2x%02x %s\n",
  714. X            byte2, byte, string);
  715. X    }
  716. X}
  717. X        
  718. END_OF_decode.c
  719. if test 462 -ne `wc -c <decode.c`; then
  720.     echo shar: \"decode.c\" unpacked with wrong size!
  721. fi
  722. # end of overwriting check
  723. fi
  724. if test -f dso1.F -a "${1}" != "-c" ; then 
  725.   echo shar: Will not over-write existing file \"dso1.F\"
  726. else
  727. echo shar: Extracting \"dso1.F\" \(2806 characters\)
  728. sed "s/^X//" >dso1.F <<'END_OF_dso1.F'
  729. XC PRINCR- PRINT CONTENTS OF ROOM
  730. XC
  731. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  732. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  733. XC WRITTEN BY R. M. SUPNIK
  734. XC
  735. XC DECLARATIONS
  736. XC
  737. X    SUBROUTINE PRINCR(FULL,RM)
  738. X    IMPLICIT INTEGER (A-Z)
  739. X    LOGICAL QEMPTY,QHERE,FULL
  740. X#include "gamestate.h"
  741. X#include "rooms.h"
  742. X#include "rflag.h"
  743. XC
  744. X#include "objects.h"
  745. X#include "oflags.h"
  746. X#include "oindex.h"
  747. X#include "advers.h"
  748. X#include "flags.h"
  749. XC PRINCR, PAGE 2
  750. XC
  751. X    J=329
  752. XC                        !ASSUME SUPERBRIEF FORMAT.
  753. X    DO 500 I=1,OLNT
  754. XC                        !LOOP ON OBJECTS
  755. X      IF(.NOT.QHERE(I,RM).OR.(and(OFLAG1(I),(VISIBT+NDSCBT)).NE.
  756. X&        VISIBT).OR.(I.EQ.AVEHIC(WINNER))) GO TO 500
  757. X      IF(.NOT.FULL.AND.(SUPERF.OR.(BRIEFF.AND.
  758. X&        (and(RFLAG(HERE),RSEEN).NE.0)))) GO TO 200
  759. XC
  760. XC DO LONG DESCRIPTION OF OBJECT.
  761. XC
  762. X      K=ODESCO(I)
  763. XC                        !GET UNTOUCHED.
  764. X      IF((K.EQ.0).OR.(and(OFLAG2(I),TCHBT).NE.0)) K=ODESC1(I)
  765. X      CALL RSPEAK(K)
  766. XC                        !DESCRIBE.
  767. X      GO TO 500
  768. XC DO SHORT DESCRIPTION OF OBJECT.
  769. XC
  770. X200      CALL RSPSUB(J,ODESC2(I))
  771. XC                        !YOU CAN SEE IT.
  772. X      J=502
  773. XC
  774. X500    CONTINUE
  775. XC
  776. XC NOW LOOP TO PRINT CONTENTS OF OBJECTS IN ROOM.
  777. XC
  778. X    DO 1000 I=1,OLNT
  779. XC                        !LOOP ON OBJECTS.
  780. X      IF(.NOT.QHERE(I,RM).OR.(and(OFLAG1(I),(VISIBT+NDSCBT)).NE.
  781. X&        VISIBT)) GO TO 1000
  782. X      IF(and(OFLAG2(I),ACTRBT).NE.0) CALL INVENT(OACTOR(I))
  783. X      IF(((and(OFLAG1(I),TRANBT).EQ.0)
  784. X&        .AND.(and(OFLAG2(I),OPENBT).EQ.0))
  785. X&        .OR.QEMPTY(I)) GO TO 1000
  786. XC
  787. XC OBJECT IS NOT EMPTY AND IS OPEN OR TRANSPARENT.
  788. XC
  789. X      J=573
  790. X      IF(I.NE.TCASE) GO TO 600
  791. XC                        !TROPHY CASE?
  792. X      J=574
  793. X      IF((BRIEFF.OR.SUPERF).AND. .NOT.FULL) GO TO 1000
  794. X600      CALL PRINCO(I,J)
  795. XC                        !PRINT CONTENTS.
  796. XC
  797. X1000    CONTINUE
  798. X    RETURN
  799. XC
  800. X    END
  801. XC INVENT- PRINT CONTENTS OF ADVENTURER
  802. XC
  803. XC DECLARATIONS
  804. XC
  805. X    SUBROUTINE INVENT(ADV)
  806. X    IMPLICIT INTEGER (A-Z)
  807. X    LOGICAL QEMPTY
  808. X#include "gamestate.h"
  809. X#include "objects.h"
  810. X#include "oflags.h"
  811. XC
  812. X#include "advers.h"
  813. XC INVENT, PAGE 2
  814. XC
  815. X    I=575
  816. XC                        !FIRST LINE.
  817. X    IF(ADV.NE.PLAYER) I=576
  818. XC                        !IF NOT ME.
  819. X    DO 10 J=1,OLNT
  820. XC                        !LOOP
  821. X      IF((OADV(J).NE.ADV).OR.(and(OFLAG1(J),VISIBT).EQ.0))
  822. X&        GO TO 10
  823. X      CALL RSPSUB(I,ODESC2(AOBJ(ADV)))
  824. X      I=0
  825. X      CALL RSPSUB(502,ODESC2(J))
  826. X10    CONTINUE
  827. XC
  828. X    IF(I.EQ.0) GO TO 25
  829. XC                        !ANY OBJECTS?
  830. X    IF(ADV.EQ.PLAYER) CALL RSPEAK(578)
  831. XC                        !NO, TELL HIM.
  832. X    RETURN
  833. XC
  834. X25    DO 100 J=1,OLNT
  835. XC                        !LOOP.
  836. X      IF((OADV(J).NE.ADV).OR.(and(OFLAG1(J),VISIBT).EQ.0).OR.
  837. X&        ((and(OFLAG1(J),TRANBT).EQ.0).AND.
  838. X&        (and(OFLAG2(J),OPENBT).EQ.0))) GO TO 100
  839. X      IF(.NOT.QEMPTY(J)) CALL PRINCO(J,573)
  840. XC                        !IF NOT EMPTY, LIST.
  841. X100    CONTINUE
  842. X    RETURN
  843. XC
  844. X    END
  845. XC PRINCO-    PRINT CONTENTS OF OBJECT
  846. XC
  847. XC DECLARATIONS
  848. XC
  849. X    SUBROUTINE PRINCO(OBJ,DESC)
  850. X    IMPLICIT INTEGER(A-Z)
  851. X#include "objects.h"
  852. XC
  853. X    CALL RSPSUB(DESC,ODESC2(OBJ))
  854. XC                        !PRINT HEADER.
  855. X    DO 100 I=1,OLNT
  856. XC                        !LOOP THRU.
  857. X      IF(OCAN(I).EQ.OBJ) CALL RSPSUB(502,ODESC2(I))
  858. X100    CONTINUE
  859. X    RETURN
  860. XC
  861. X    END
  862. END_OF_dso1.F
  863. if test 2806 -ne `wc -c <dso1.F`; then
  864.     echo shar: \"dso1.F\" unpacked with wrong size!
  865. fi
  866. # end of overwriting check
  867. fi
  868. if test -f dso3.F -a "${1}" != "-c" ; then 
  869.   echo shar: Will not over-write existing file \"dso3.F\"
  870. else
  871. echo shar: Extracting \"dso3.F\" \(2686 characters\)
  872. sed "s/^X//" >dso3.F <<'END_OF_dso3.F'
  873. XC FINDXT- FIND EXIT FROM ROOM
  874. XC
  875. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  876. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  877. XC WRITTEN BY R. M. SUPNIK
  878. XC
  879. XC DECLARATIONS
  880. XC
  881. X    LOGICAL FUNCTION FINDXT(DIR,RM)
  882. X    IMPLICIT INTEGER (A-Z)
  883. X#include "rooms.h"
  884. X#include "exits.h"
  885. X#include "curxt.h"
  886. X#include "xpars.h"
  887. XC
  888. X    FINDXT=.TRUE.
  889. XC                        !ASSUME WINS.
  890. X    XI=REXIT(RM)
  891. XC                        !FIND FIRST ENTRY.
  892. X    IF(XI.EQ.0) GO TO 1000
  893. XC                        !NO EXITS?
  894. XC
  895. X100    I=TRAVEL(XI)
  896. XC                        !GET ENTRY.
  897. X    XROOM1=and(I,XRMASK)
  898. X    XTYPE=and((and(I,not(XLFLAG))/XFSHFT),XFMASK)+1
  899. X    GO TO (110,120,130,130),XTYPE
  900. XC                        !BRANCH ON ENTRY.
  901. X    CALL BUG(10,XTYPE)
  902. XC
  903. X130    XOBJ=and(TRAVEL(XI+2),XRMASK)
  904. X    XACTIO=TRAVEL(XI+2)/XASHFT
  905. X120    XSTRNG=TRAVEL(XI+1)
  906. XC                        !DOOR/CEXIT/NEXIT - STRING.
  907. X110    XI=XI+XELNT(XTYPE)
  908. XC                        !ADVANCE TO NEXT ENTRY.
  909. X    IF(and(I,XDMASK).EQ.DIR) RETURN
  910. X    IF(and(I,XLFLAG).EQ.0) GO TO 100
  911. X1000    FINDXT=.FALSE.
  912. XC                        !YES, LOSE.
  913. X    RETURN
  914. X    END
  915. XC FWIM- FIND WHAT I MEAN
  916. XC
  917. XC DECLARATIONS
  918. XC
  919. X    INTEGER FUNCTION FWIM(F1,F2,RM,CON,ADV,NOCARE)
  920. X    IMPLICIT INTEGER (A-Z)
  921. X    LOGICAL NOCARE
  922. X#include "objects.h"
  923. X#include "oflags.h"
  924. XC
  925. X    FWIM=0
  926. XC                        !ASSUME NOTHING.
  927. X    DO 1000 I=1,OLNT
  928. XC                        !LOOP
  929. X      IF(((RM.EQ.0).OR.(OROOM(I).NE.RM)) .AND.
  930. X&        ((ADV.EQ.0).OR.(OADV(I).NE.ADV)) .AND.
  931. X&        ((CON.EQ.0).OR.(OCAN(I).NE.CON)))
  932. X&        GO TO 1000
  933. XC
  934. XC OBJECT IS ON LIST... IS IT A MATCH?
  935. XC
  936. X      IF(and(OFLAG1(I),VISIBT).EQ.0) GO TO 1000
  937. X      IF(and(not(NOCARE),(and(OFLAG1(I),TAKEBT).EQ.0)) .OR.
  938. X&        ((and(OFLAG1(I),F1).EQ.0).AND.
  939. X&         (and(OFLAG2(I),F2).EQ.0))) GO TO 500
  940. X      IF(FWIM.EQ.0) GO TO 400
  941. XC                        !ALREADY GOT SOMETHING?
  942. X      FWIM=-FWIM
  943. XC                        !YES, AMBIGUOUS.
  944. X      RETURN
  945. XC
  946. X400      FWIM=I
  947. XC                        !NOTE MATCH.
  948. XC
  949. XC DOES OBJECT CONTAIN A MATCH?
  950. XC
  951. X500      IF(and(OFLAG2(I),OPENBT).EQ.0) GO TO 1000
  952. X      DO 700 J=1,OLNT
  953. XC                        !NO, SEARCH CONTENTS.
  954. X        IF((OCAN(J).NE.I).OR.(and(OFLAG1(J),VISIBT).EQ.0) .OR.
  955. X&        ((and(OFLAG1(J),F1).EQ.0).AND.
  956. X&         (and(OFLAG2(J),F2).EQ.0))) GO TO 700
  957. X        IF(FWIM.EQ.0) GO TO 600
  958. X        FWIM=-FWIM
  959. X        RETURN
  960. XC
  961. X600        FWIM=J
  962. X700      CONTINUE
  963. X1000    CONTINUE
  964. X    RETURN
  965. X    END
  966. XC YESNO- OBTAIN YES/NO ANSWER
  967. XC
  968. XC CALLED BY-
  969. XC
  970. XC    YES-IS-TRUE=YESNO(QUESTION,YES-STRING,NO-STRING)
  971. XC
  972. X    LOGICAL FUNCTION YESNO(Q,Y,N)
  973. X    IMPLICIT INTEGER(A-Z)
  974. X    COMMON /CHAN/ INPCH,OUTCH,DBCH
  975. X    CHARACTER ANS
  976. XC
  977. X100    CALL RSPEAK(Q)
  978. XC                        !ASK
  979. X#ifdef PDP
  980. X    call rdchr(ANS)
  981. X#else
  982. X    READ(INPCH,110) ANS
  983. X#endif PDP
  984. XC                        !GET ANSWER
  985. X110    FORMAT(A1)
  986. X    IF((ANS.EQ.'Y').OR.(ANS.EQ.'y')) GO TO 200
  987. X    IF((ANS.EQ.'N').OR.(ANS.EQ.'n')) GO TO 300
  988. X    CALL RSPEAK(6)
  989. XC                        !SCOLD.
  990. X    GO TO 100
  991. XC
  992. X200    YESNO=.TRUE.
  993. XC                        !YES,
  994. X    CALL RSPEAK(Y)
  995. XC                        !OUT WITH IT.
  996. X    RETURN
  997. XC
  998. X300    YESNO=.FALSE.
  999. XC                        !NO,
  1000. X    CALL RSPEAK(N)
  1001. XC                        !LIKEWISE.
  1002. X    RETURN
  1003. XC
  1004. X    END
  1005. END_OF_dso3.F
  1006. if test 2686 -ne `wc -c <dso3.F`; then
  1007.     echo shar: \"dso3.F\" unpacked with wrong size!
  1008. fi
  1009. # end of overwriting check
  1010. fi
  1011. if test -f dso4.F -a "${1}" != "-c" ; then 
  1012.   echo shar: Will not over-write existing file \"dso4.F\"
  1013. else
  1014. echo shar: Extracting \"dso4.F\" \(2615 characters\)
  1015. sed "s/^X//" >dso4.F <<'END_OF_dso4.F'
  1016. XC ROBADV-- STEAL WINNER'S VALUABLES
  1017. XC
  1018. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  1019. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  1020. XC WRITTEN BY R. M. SUPNIK
  1021. XC
  1022. XC DECLARATIONS
  1023. XC
  1024. X    INTEGER FUNCTION ROBADV(ADV,NR,NC,NA)
  1025. X    IMPLICIT INTEGER (A-Z)
  1026. X#include "objects.h"
  1027. X#include "oflags.h"
  1028. XC
  1029. X    ROBADV=0
  1030. XC                        !COUNT OBJECTS
  1031. X    DO 100 I=1,OLNT
  1032. X      IF((OADV(I).NE.ADV).OR.(OTVAL(I).LE.0).OR.
  1033. X&        (and(OFLAG2(I),SCRDBT).NE.0)) GO TO 100
  1034. X      CALL NEWSTA(I,0,NR,NC,NA)
  1035. XC                        !STEAL OBJECT
  1036. X      ROBADV=ROBADV+1
  1037. X100    CONTINUE
  1038. X    RETURN
  1039. X    END
  1040. XC ROBRM-- STEAL ROOM VALUABLES
  1041. XC
  1042. XC DECLARATIONS
  1043. XC
  1044. X    INTEGER FUNCTION ROBRM(RM,PR,NR,NC,NA)
  1045. X    IMPLICIT INTEGER (A-Z)
  1046. X    LOGICAL PROB,QHERE
  1047. X#include "objects.h"
  1048. X#include "oflags.h"
  1049. XC
  1050. X    ROBRM=0
  1051. XC                        !COUNT OBJECTS
  1052. X    DO 100 I=1,OLNT
  1053. XC                        !LOOP ON OBJECTS.
  1054. X      IF(.NOT. QHERE(I,RM)) GO TO 100
  1055. X      IF((OTVAL(I).LE.0).OR.(and(OFLAG2(I),SCRDBT).NE.0).OR.
  1056. X&        (and(OFLAG1(I),VISIBT).EQ.0).OR.(.NOT.PROB(PR,PR)))
  1057. X&        GO TO 50
  1058. X      CALL NEWSTA(I,0,NR,NC,NA)
  1059. X      ROBRM=ROBRM+1
  1060. X      OFLAG2(I)=or(OFLAG2(I),TCHBT)
  1061. X      GO TO 100
  1062. X50      IF(and(OFLAG2(I),ACTRBT).NE.0)
  1063. X&        ROBRM=ROBRM+ROBADV(OACTOR(I),NR,NC,NA)
  1064. X100    CONTINUE
  1065. X    RETURN
  1066. X    END
  1067. XC WINNIN-- SEE IF VILLAIN IS WINNING
  1068. XC
  1069. XC DECLARATIONS
  1070. XC
  1071. X    LOGICAL FUNCTION WINNIN(VL,HR)
  1072. X    IMPLICIT INTEGER (A-Z)
  1073. X    LOGICAL PROB
  1074. X#include "objects.h"
  1075. XC
  1076. X    VS=OCAPAC(VL)
  1077. XC                        !VILLAIN STRENGTH
  1078. X    PS=VS-FIGHTS(HR,.TRUE.)
  1079. XC                        !HIS MARGIN OVER HERO
  1080. X    WINNIN=PROB(90,100)
  1081. X    IF(PS.GT.3) RETURN
  1082. XC                        !+3... 90% WINNING
  1083. X    WINNIN=PROB(75,85)
  1084. X    IF(PS.GT.0) RETURN
  1085. XC                        !>0... 75% WINNING
  1086. X    WINNIN=PROB(50,30)
  1087. X    IF(PS.EQ.0) RETURN
  1088. XC                        !=0... 50% WINNING
  1089. X    WINNIN=PROB(25,25)
  1090. X    IF(VS.GT.1) RETURN
  1091. XC                        !ANY VILLAIN STRENGTH.
  1092. X    WINNIN=PROB(10,0)
  1093. X    RETURN
  1094. X    END
  1095. XC FIGHTS-- COMPUTE FIGHT STRENGTH
  1096. XC
  1097. XC DECLARATIONS
  1098. XC
  1099. X    INTEGER FUNCTION FIGHTS(H,FLG)
  1100. X    IMPLICIT INTEGER (A-Z)
  1101. X    LOGICAL FLG
  1102. XC
  1103. XC GAME STATE
  1104. XC
  1105. X#include "state.h"
  1106. X#include "advers.h"
  1107. XC
  1108. XC FUNCTIONS AND DATA
  1109. XC
  1110. X    DATA SMAX/7/,SMIN/2/
  1111. XC
  1112. X    FIGHTS=SMIN+((((SMAX-SMIN)*ASCORE(H))+(MXSCOR/2))/MXSCOR)
  1113. X    IF(FLG) FIGHTS=FIGHTS+ASTREN(H)
  1114. X    RETURN
  1115. X    END
  1116. XC VILSTR-    COMPUTE VILLAIN STRENGTH
  1117. XC
  1118. XC DECLARATIONS
  1119. XC
  1120. X    INTEGER FUNCTION VILSTR(V)
  1121. X    IMPLICIT INTEGER (A-Z)
  1122. X#include "parser.h"
  1123. X#include "objects.h"
  1124. X#include "oflags.h"
  1125. X#include "oindex.h"
  1126. X#include "villians.h"
  1127. X#include "flags.h"
  1128. XC VILSTR, PAGE 2
  1129. XC
  1130. X    VILSTR=OCAPAC(V)
  1131. X    IF(VILSTR.LE.0) RETURN
  1132. X    IF((V.NE.THIEF).OR..NOT.THFENF) GO TO 100
  1133. X    THFENF=.FALSE.
  1134. XC                        !THIEF UNENGROSSED.
  1135. X    VILSTR=MIN0(VILSTR,2)
  1136. XC                        !NO BETTER THAN 2.
  1137. XC
  1138. X100    DO 200 I=1,VLNT
  1139. XC                        !SEE IF  BEST WEAPON.
  1140. X      IF((VILLNS(I).EQ.V).AND.(PRSI.EQ.VBEST(I)))
  1141. X&        VILSTR=MAX0(1,VILSTR-1)
  1142. X200    CONTINUE
  1143. X    RETURN
  1144. X    END
  1145. END_OF_dso4.F
  1146. if test 2615 -ne `wc -c <dso4.F`; then
  1147.     echo shar: \"dso4.F\" unpacked with wrong size!
  1148. fi
  1149. # end of overwriting check
  1150. fi
  1151. if test -f dso5.F -a "${1}" != "-c" ; then 
  1152.   echo shar: Will not over-write existing file \"dso5.F\"
  1153. else
  1154. echo shar: Extracting \"dso5.F\" \(2654 characters\)
  1155. sed "s/^X//" >dso5.F <<'END_OF_dso5.F'
  1156. XC
  1157. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  1158. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  1159. XC WRITTEN BY R. M. SUPNIK
  1160. XC
  1161. X#ifndef PDP    /* replaced by C function for pdp */
  1162. XC GTTIME-- GET TOTAL TIME PLAYED
  1163. XC
  1164. XC DECLARATIONS
  1165. XC
  1166. X     SUBROUTINE GTTIME(T)
  1167. X     IMPLICIT INTEGER(A-Z)
  1168. XC
  1169. X     COMMON /TIME/ PLTIME,SHOUR,SMIN,SSEC
  1170. XC
  1171. X     CALL ITIME(H,M,S)
  1172. X     T=((H*60)+M)-((SHOUR*60)+SMIN)
  1173. X     IF(T.LT.0) T=T+1440
  1174. X     T=T+PLTIME
  1175. X     RETURN
  1176. X     END
  1177. X#endif PDP
  1178. XC OPNCLS-- PROCESS OPEN/CLOSE FOR DOORS
  1179. XC
  1180. XC DECLARATIONS
  1181. XC
  1182. X    LOGICAL FUNCTION OPNCLS(OBJ,SO,SC)
  1183. X    IMPLICIT INTEGER (A-Z)
  1184. X    LOGICAL QOPEN
  1185. X#include "parser.h"
  1186. X#include "objects.h"
  1187. X#include "oflags.h"
  1188. X#include "verbs.h"
  1189. XC
  1190. XC FUNCTIONS AND DATA
  1191. XC
  1192. X    QOPEN(O)=and(OFLAG2(O),OPENBT).NE.0
  1193. XC
  1194. X    OPNCLS=.TRUE.
  1195. XC                        !ASSUME WINS.
  1196. X    IF(PRSA.EQ.CLOSEW) GO TO 100
  1197. XC                        !CLOSE?
  1198. X    IF(PRSA.EQ.OPENW) GO TO 50
  1199. XC                        !OPEN?
  1200. X    OPNCLS=.FALSE.
  1201. XC                        !LOSE
  1202. X    RETURN
  1203. XC
  1204. X50    IF(QOPEN(OBJ)) GO TO 200
  1205. XC                        !OPEN... IS IT?
  1206. X    CALL RSPEAK(SO)
  1207. X    OFLAG2(OBJ)=or(OFLAG2(OBJ),OPENBT)
  1208. X    RETURN
  1209. XC
  1210. X100    IF(.NOT.QOPEN(OBJ)) GO TO 200
  1211. XC                        !CLOSE... IS IT?
  1212. X    CALL RSPEAK(SC)
  1213. X    OFLAG2(OBJ)=and(OFLAG2(OBJ),not(OPENBT))
  1214. X    RETURN
  1215. XC
  1216. X200    CALL RSPEAK(125+RND(3))
  1217. XC                        !DUMMY.
  1218. X    RETURN
  1219. X    END
  1220. XC LIT-- IS ROOM LIT?
  1221. XC
  1222. XC DECLARATIONS
  1223. XC
  1224. X    LOGICAL FUNCTION LIT(RM)
  1225. X    IMPLICIT INTEGER (A-Z)
  1226. X    LOGICAL QHERE
  1227. X#include "rooms.h"
  1228. X#include "rflag.h"
  1229. X#include "objects.h"
  1230. X#include "oflags.h"
  1231. X#include "advers.h"
  1232. XC
  1233. X    LIT=.TRUE.
  1234. XC                        !ASSUME WINS
  1235. X    IF(and(RFLAG(RM),RLIGHT).NE.0) RETURN
  1236. XC
  1237. X    DO 1000 I=1,OLNT
  1238. XC                        !LOOK FOR LIT OBJ
  1239. X      IF(QHERE(I,RM)) GO TO 100
  1240. XC                        !IN ROOM?
  1241. X      OA=OADV(I)
  1242. XC                        !NO
  1243. X      IF(OA.LE.0) GO TO 1000
  1244. XC                        !ON ADV?
  1245. X      IF(AROOM(OA).NE.RM) GO TO 1000
  1246. XC                        !ADV IN ROOM?
  1247. XC
  1248. XC OBJ IN ROOM OR ON ADV IN ROOM
  1249. XC
  1250. X100      IF(and(OFLAG1(I),ONBT).NE.0) RETURN
  1251. X      IF((and(OFLAG1(I),VISIBT).EQ.0).OR.
  1252. X&        ((and(OFLAG1(I),TRANBT).EQ.0).AND.
  1253. X&        (and(OFLAG2(I),OPENBT).EQ.0))) GO TO 1000
  1254. XC
  1255. XC OBJ IS VISIBLE AND OPEN OR TRANSPARENT
  1256. XC
  1257. X      DO 500 J=1,OLNT
  1258. X        IF((OCAN(J).EQ.I).AND.(and(OFLAG1(J),ONBT).NE.0))
  1259. X&        RETURN
  1260. X500      CONTINUE
  1261. X1000    CONTINUE
  1262. X    LIT=.FALSE.
  1263. X    RETURN
  1264. X    END
  1265. XC WEIGHT- RETURNS SUM OF WEIGHT OF QUALIFYING OBJECTS
  1266. XC
  1267. XC DECLARATIONS
  1268. XC
  1269. X    INTEGER FUNCTION WEIGHT(RM,CN,AD)
  1270. X    IMPLICIT INTEGER (A-Z)
  1271. X    LOGICAL QHERE
  1272. X#include "objects.h"
  1273. XC
  1274. X    WEIGHT=0
  1275. X    DO 100 I=1,OLNT
  1276. XC                        !OMIT BIG FIXED ITEMS.
  1277. X      IF(OSIZE(I).GE.10000) GO TO 100
  1278. XC                        !IF FIXED, FORGET IT.
  1279. X      IF((QHERE(I,RM).AND.(RM.NE.0)).OR.
  1280. X&        ((OADV(I).EQ.AD).AND.(AD.NE.0))) GO TO 50
  1281. X      J=I
  1282. XC                        !SEE IF CONTAINED.
  1283. X25      J=OCAN(J)
  1284. XC                        !GET NEXT LEVEL UP.
  1285. X      IF(J.EQ.0) GO TO 100
  1286. XC                        !END OF LIST?
  1287. X      IF(J.NE.CN) GO TO 25
  1288. X50      WEIGHT=WEIGHT+OSIZE(I)
  1289. X100    CONTINUE
  1290. X    RETURN
  1291. X    END
  1292. END_OF_dso5.F
  1293. if test 2654 -ne `wc -c <dso5.F`; then
  1294.     echo shar: \"dso5.F\" unpacked with wrong size!
  1295. fi
  1296. # end of overwriting check
  1297. fi
  1298. if test -f dso6.F -a "${1}" != "-c" ; then 
  1299.   echo shar: Will not over-write existing file \"dso6.F\"
  1300. else
  1301. echo shar: Extracting \"dso6.F\" \(2359 characters\)
  1302. sed "s/^X//" >dso6.F <<'END_OF_dso6.F'
  1303. XC GHERE--    IS GLOBAL ACTUALLY IN THIS ROOM?
  1304. XC
  1305. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  1306. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  1307. XC WRITTEN BY R. M. SUPNIK
  1308. XC
  1309. XC DECLARATIONS
  1310. XC
  1311. X    LOGICAL FUNCTION GHERE(OBJ,RM)
  1312. X    IMPLICIT INTEGER(A-Z)
  1313. X#include "rooms.h"
  1314. X#include "rflag.h"
  1315. X#include "rindex.h"
  1316. XC
  1317. X    COMMON /STAR/ MBASE,STRBIT
  1318. XC GHERE, PAGE 2
  1319. XC
  1320. X    GHERE=.TRUE.
  1321. XC                        !ASSUME WINS.
  1322. X    GO TO (1000,1000,1000,1000,1000,1000,
  1323. X&        1000,1000,1000,1000,1000,
  1324. X&        2000,3000,4000,5000,5000,5000,6000,
  1325. X&        7000,8000,9000,9100,8000,10000,11000),OBJ-STRBIT
  1326. X    CALL BUG(60,OBJ)
  1327. XC
  1328. XC 1000--    STARS ARE ALWAYS HERE
  1329. XC
  1330. X1000    RETURN
  1331. XC
  1332. XC 2000--    BIRD
  1333. XC
  1334. X2000    GHERE=((RM.GE.FORE1).AND.(RM.LT.CLEAR)).OR.(RM.EQ.MTREE)
  1335. X    RETURN
  1336. XC
  1337. XC 3000--    TREE
  1338. XC
  1339. X3000    GHERE=((RM.GE.FORE1).AND.(RM.LT.CLEAR)).AND.(RM.NE.FORE3)
  1340. X    RETURN
  1341. XC
  1342. XC 4000--    NORTH WALL
  1343. XC
  1344. X4000    GHERE=((RM.GE.BKVW).AND.(RM.LE.BKBOX)).OR.(RM.EQ.CPUZZ)
  1345. X    RETURN
  1346. XC
  1347. XC 5000--    EAST, SOUTH, WEST WALLS
  1348. XC
  1349. X5000    GHERE=((RM.GE.BKVW).AND.(RM.LT.BKBOX)).OR.(RM.EQ.CPUZZ)
  1350. X    RETURN
  1351. XC
  1352. XC 6000--    GLOBAL WATER
  1353. XC
  1354. X6000    GHERE=and(RFLAG(RM),(RWATER+RFILL)).NE.0
  1355. X    RETURN
  1356. XC
  1357. XC 7000--    GLOBAL GUARDIANS
  1358. XC
  1359. X7000    GHERE=((RM.GE.MRC).AND.(RM.LE.MRD)).OR.
  1360. X&        ((RM.GE.MRCE).AND.(RM.LE.MRDW)).OR.(RM.EQ.INMIR)
  1361. X    RETURN
  1362. XC
  1363. XC 8000--    ROSE/CHANNEL
  1364. XC
  1365. X8000    GHERE=((RM.GE.MRA).AND.(RM.LE.MRD)).OR.(RM.EQ.INMIR)
  1366. X    RETURN
  1367. XC
  1368. XC 9000--    MIRROR
  1369. XC 9100        PANEL
  1370. XC
  1371. X9100    IF(RM.EQ.FDOOR) RETURN
  1372. XC                        !PANEL AT FDOOR.
  1373. X9000    GHERE=((RM.GE.MRA).AND.(RM.LE.MRC)).OR.
  1374. X&        ((RM.GE.MRAE).AND.(RM.LE.MRCW))
  1375. X    RETURN
  1376. XC
  1377. XC 10000--    MASTER
  1378. XC
  1379. X10000    GHERE=(RM.EQ.FDOOR).OR.(RM.EQ.NCORR).OR.(RM.EQ.PARAP).OR.
  1380. X&        (RM.EQ.CELL)
  1381. X    RETURN
  1382. XC
  1383. XC 11000--    LADDER
  1384. XC
  1385. X11000    GHERE=(RM.EQ.CPUZZ)
  1386. X    RETURN
  1387. XC
  1388. X    END
  1389. XC MRHERE--    IS MIRROR HERE?
  1390. XC
  1391. XC DECLARATIONS
  1392. XC
  1393. X    INTEGER FUNCTION MRHERE(RM)
  1394. X    IMPLICIT INTEGER(A-Z)
  1395. XC
  1396. XC ROOMS
  1397. X#include "rindex.h"
  1398. X#include "flags.h"
  1399. XC MRHERE, PAGE 2
  1400. XC
  1401. X    IF((RM.LT.MRAE).OR.(RM.GT.MRDW)) GO TO 100
  1402. XC
  1403. XC RM IS AN E-W ROOM, MIRROR MUST BE N-S (MDIR= 0 OR 180)
  1404. XC
  1405. X    MRHERE=1
  1406. XC                        !ASSUME MIRROR 1 HERE.
  1407. X    IF(MOD(RM-MRAE,2).EQ.(MDIR/180)) MRHERE=2
  1408. X    RETURN
  1409. XC
  1410. XC RM IS NORTH OR SOUTH OF MIRROR.  IF MIRROR IS N-S OR NOT
  1411. XC WITHIN ONE ROOM OF RM, LOSE.
  1412. XC
  1413. X100    MRHERE=0
  1414. X    IF((IABS(MLOC-RM).NE.1).OR.(MOD(MDIR,180).EQ.0)) RETURN
  1415. XC
  1416. XC RM IS WITHIN ONE OF MLOC, AND MDIR IS E-W
  1417. XC
  1418. X    MRHERE=1
  1419. X    IF(((RM.LT.MLOC).AND.(MDIR.LT.180)).OR.
  1420. X&      ((RM.GT.MLOC).AND.(MDIR.GT.180))) MRHERE=2
  1421. X    RETURN
  1422. X    END
  1423. END_OF_dso6.F
  1424. if test 2359 -ne `wc -c <dso6.F`; then
  1425.     echo shar: \"dso6.F\" unpacked with wrong size!
  1426. fi
  1427. # end of overwriting check
  1428. fi
  1429. if test -f dso7.F -a "${1}" != "-c" ; then 
  1430.   echo shar: Will not over-write existing file \"dso7.F\"
  1431. else
  1432. echo shar: Extracting \"dso7.F\" \(2920 characters\)
  1433. sed "s/^X//" >dso7.F <<'END_OF_dso7.F'
  1434. XC ENCRYP--    ENCRYPT PASSWORD
  1435. XC
  1436. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  1437. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  1438. XC WRITTEN BY R. M. SUPNIK
  1439. XC
  1440. XC DECLARATIONS
  1441. XC
  1442. X    SUBROUTINE ENCRYP(INW,OUTW)
  1443. X    IMPLICIT INTEGER(A-Z)
  1444. X    CHARACTER INW(6),OUTW(6)
  1445. X    CHARACTER  KEYW(6),UKEYW(6)
  1446. X    INTEGER UINW(6)
  1447. X    DATA KEYW/'E','C','O','R','M','S'/
  1448. XC
  1449. X    UINWS=0
  1450. XC                        !UNBIASED INW SUM.
  1451. X    UKEYWS=0
  1452. XC                        !UNBIASED KEYW SUM.
  1453. X    J=1
  1454. XC                        !POINTER IN KEYWORD.
  1455. X    DO 100 I=1,6
  1456. XC                        !UNBIAS, COMPUTE SUMS.
  1457. X      UKEYW(I)=char(ichar(KEYW(I))-64)
  1458. X      IF(INW(J).LE.char(64)) J=1
  1459. X      UINW(I)=ichar(ichar(INW(J))-64)
  1460. X      UKEYWS=UKEYWS+ichar(UKEYW(I))
  1461. X      UINWS=UINWS+UINW(I)
  1462. X      J=J+1
  1463. X100    CONTINUE
  1464. XC
  1465. X    USUM=MOD(UINWS,8)+(8*MOD(UKEYWS,8))
  1466. XC                        !COMPUTE MASK.
  1467. X    DO 200 I=1,6
  1468. X      J=and(xor(xor(ichar(UINW(I)),ichar(UKEYW(I))),USUM),31)
  1469. X      USUM=MOD(USUM+1,32)
  1470. X      IF(J.GT.26) J=MOD(J,26)
  1471. X      OUTW(I)=char(MAX0(1,J)+64)
  1472. X200    CONTINUE
  1473. X    RETURN
  1474. XC
  1475. X    END
  1476. XC CPGOTO--    MOVE TO NEXT STATE IN PUZZLE ROOM
  1477. XC
  1478. XC DECLARATIONS
  1479. XC
  1480. X    SUBROUTINE CPGOTO(ST)
  1481. X    IMPLICIT INTEGER(A-Z)
  1482. XC
  1483. X    COMMON /HYPER/ HFACTR
  1484. X#include "rooms.h"
  1485. X#include "rflag.h"
  1486. X#include "rindex.h"
  1487. X#include "objects.h"
  1488. X#include "oflags.h"
  1489. X#include "flags.h"
  1490. XC CPGOTO, PAGE 2
  1491. XC
  1492. X    RFLAG(CPUZZ)=and(RFLAG(CPUZZ),not(RSEEN))
  1493. X    DO 100 I=1,OLNT
  1494. XC                        !RELOCATE OBJECTS.
  1495. X      IF((OROOM(I).EQ.CPUZZ).AND.
  1496. X&        (and(OFLAG2(I),(ACTRBT+VILLBT)).EQ.0))
  1497. X&        CALL NEWSTA(I,0,CPHERE*HFACTR,0,0)
  1498. X      IF(OROOM(I).EQ.(ST*HFACTR))
  1499. X&        CALL NEWSTA(I,0,CPUZZ,0,0)
  1500. X100    CONTINUE
  1501. X    CPHERE=ST
  1502. X    RETURN
  1503. XC
  1504. X    END
  1505. XC CPINFO--    DESCRIBE PUZZLE ROOM
  1506. XC
  1507. XC DECLARATIONS
  1508. XC
  1509. X    SUBROUTINE CPINFO(RMK,ST)
  1510. X    IMPLICIT INTEGER(A-Z)
  1511. X    INTEGER DGMOFT(8)
  1512. X    CHARACTER  DGM(8),PICT(5),QMK
  1513. XC
  1514. X    COMMON /CHAN/ INPCH,OUTCH,DBCH
  1515. XC
  1516. XC PUZZLE ROOM
  1517. XC
  1518. X    COMMON /PUZZLE/ CPDR(16),CPWL(8),CPVEC(64)
  1519. X#include "flags.h"
  1520. XC
  1521. XC FUNCTIONS AND LOCAL DATA
  1522. XC
  1523. XC
  1524. X    DATA DGMOFT/-9,-8,-7,-1,1,7,8,9/
  1525. X#ifdef PDP
  1526. XC
  1527. XC    PICT, DGM and QMK have been changed from two to
  1528. XC    one character in length. Puzout prints two copies.
  1529. XC
  1530. X    DATA PICT/'S','S','S',' ','M'/
  1531. X    DATA QMK/'?'/
  1532. X#else
  1533. X    DATA PICT/'SS','SS','SS','  ','MM'/
  1534. X    DATA QMK/'??'/
  1535. X#endif PDP
  1536. XC CPINFO, PAGE 2
  1537. XC
  1538. X    CALL RSPEAK(RMK)
  1539. X    DO 100 I=1,8
  1540. X      J=DGMOFT(I)
  1541. X      DGM(I)=PICT(CPVEC(ST+J)+4)
  1542. XC                        !GET PICTURE ELEMENT.
  1543. X      IF((IABS(J).EQ.1).OR.(IABS(J).EQ.8)) GO TO 100
  1544. X      K=8
  1545. X      IF(J.LT.0) K=-8
  1546. XC                        !GET ORTHO DIR.
  1547. X      L=J-K
  1548. X      IF((CPVEC(ST+K).NE.0).AND.(CPVEC(ST+L).NE.0))
  1549. X&        DGM(I)=QMK
  1550. X100    CONTINUE
  1551. X#ifdef PDP
  1552. X    call puzout(DGM(1))
  1553. X#else
  1554. X     WRITE(OUTCH,10) DGM
  1555. X#endif
  1556. XC
  1557. X    IF(ST.EQ.10) CALL RSPEAK(870)
  1558. XC                        !AT HOLE?
  1559. X    IF(ST.EQ.37) CALL RSPEAK(871)
  1560. XC                        !AT NICHE?
  1561. X    I=872
  1562. XC                        !DOOR OPEN?
  1563. X    IF(CPOUTF) I=873
  1564. X    IF(ST.EQ.52) CALL RSPEAK(I)
  1565. XC                        !AT DOOR?
  1566. X    IF(CPVEC(ST+1).EQ.-2) CALL RSPEAK(874)
  1567. XC                        !EAST LADDER?
  1568. X    IF(CPVEC(ST-1).EQ.-3) CALL RSPEAK(875)
  1569. XC                        !WEST LADDER?
  1570. X    RETURN
  1571. XC
  1572. X#ifndef PDP
  1573. X10    FORMAT('       |',A2,1X,A2,1X,A2,'|'/,
  1574. X&    ' West  |',A2,' .. ',A2,'|  East',/
  1575. X&    '       |',A2,1X,A2,1X,A2,'|')
  1576. X#endif PDP
  1577. XC
  1578. X    END
  1579. END_OF_dso7.F
  1580. if test 2920 -ne `wc -c <dso7.F`; then
  1581.     echo shar: \"dso7.F\" unpacked with wrong size!
  1582. fi
  1583. # end of overwriting check
  1584. fi
  1585. if test -f dungeon.sh -a "${1}" != "-c" ; then 
  1586.   echo shar: Will not over-write existing file \"dungeon.sh\"
  1587. else
  1588. echo shar: Extracting \"dungeon.sh\" \(249 characters\)
  1589. sed "s/^X//" >dungeon.sh <<'END_OF_dungeon.sh'
  1590. X: sh script to invoke the dungeon game on the pdp
  1591. XDLIB=/usr/games/lib/dunlib
  1592. Xcase $# in
  1593. X    0) $DLIB/listen| $DLIB/dungpdp| $DLIB/speak;;
  1594. X    1) $DLIB/listen dungeon.sav| $DLIB/dungpdp| $DLIB/speak;;
  1595. X    *) $DLIB/listen $2| $DLIB/dungpdp| $DLIB/speak;;
  1596. Xesac
  1597. END_OF_dungeon.sh
  1598. if test 249 -ne `wc -c <dungeon.sh`; then
  1599.     echo shar: \"dungeon.sh\" unpacked with wrong size!
  1600. fi
  1601. chmod +x dungeon.sh
  1602. # end of overwriting check
  1603. fi
  1604. if test -f exits.h -a "${1}" != "-c" ; then 
  1605.   echo shar: Will not over-write existing file \"exits.h\"
  1606. else
  1607. echo shar: Extracting \"exits.h\" \(45 characters\)
  1608. sed "s/^X//" >exits.h <<'END_OF_exits.h'
  1609. XC
  1610. XC EXITS
  1611. XC
  1612. X    COMMON /EXITS/ XLNT,TRAVEL(900)
  1613. END_OF_exits.h
  1614. if test 45 -ne `wc -c <exits.h`; then
  1615.     echo shar: \"exits.h\" unpacked with wrong size!
  1616. fi
  1617. # end of overwriting check
  1618. fi
  1619. if test -f files.h -a "${1}" != "-c" ; then 
  1620.   echo shar: Will not over-write existing file \"files.h\"
  1621. else
  1622. echo shar: Extracting \"files.h\" \(159 characters\)
  1623. sed "s/^X//" >files.h <<'END_OF_files.h'
  1624. X#ifndef DDIR
  1625. X#define DDIR        '/usr/games/lib/dunlib
  1626. X#endif
  1627. X
  1628. X#define INDXFILE    DDIR/dindx.dat'
  1629. X#define TEXTFILE    DDIR/dtext.dat'
  1630. X#define RINDEXFILE    DDIR/rtext.dat'
  1631. END_OF_files.h
  1632. if test 159 -ne `wc -c <files.h`; then
  1633.     echo shar: \"files.h\" unpacked with wrong size!
  1634. fi
  1635. # end of overwriting check
  1636. fi
  1637. if test -f flags.h -a "${1}" != "-c" ; then 
  1638.   echo shar: Will not over-write existing file \"flags.h\"
  1639. else
  1640. echo shar: Extracting \"flags.h\" \(1091 characters\)
  1641. sed "s/^X//" >flags.h <<'END_OF_flags.h'
  1642. XC
  1643. XC FLAGS
  1644. XC
  1645. X    LOGICAL TROLLF,CAGESF,BUCKTF,CAROFF,CAROZF,LWTIDF
  1646. X    LOGICAL DOMEF,GLACRF,ECHOF,RIDDLF,LLDF,CYCLOF
  1647. X    LOGICAL MAGICF,LITLDF,SAFEF,GNOMEF,GNODRF,MIRRMF
  1648. X    LOGICAL EGYPTF,ONPOLF,BLABF,BRIEFF,SUPERF,BUOYF
  1649. X    LOGICAL GRUNLF,GATEF,RAINBF,CAGETF,EMPTHF,DEFLAF
  1650. X    LOGICAL GLACMF,FROBZF,ENDGMF,BADLKF,THFENF,SINGSF
  1651. X    LOGICAL MRPSHF,MROPNF,WDOPNF,MR1F,MR2F,INQSTF
  1652. X    LOGICAL FOLLWF,SPELLF,CPOUTF,CPUSHF
  1653. X    COMMON /FINDEX/ TROLLF,CAGESF,BUCKTF,CAROFF,CAROZF,LWTIDF,
  1654. X&        DOMEF,GLACRF,ECHOF,RIDDLF,LLDF,CYCLOF,
  1655. X&        MAGICF,LITLDF,SAFEF,GNOMEF,GNODRF,MIRRMF,
  1656. X&        EGYPTF,ONPOLF,BLABF,BRIEFF,SUPERF,BUOYF,
  1657. X&        GRUNLF,GATEF,RAINBF,CAGETF,EMPTHF,DEFLAF,
  1658. X&        GLACMF,FROBZF,ENDGMF,BADLKF,THFENF,SINGSF,
  1659. X&        MRPSHF,MROPNF,WDOPNF,MR1F,MR2F,INQSTF,
  1660. X&        FOLLWF,SPELLF,CPOUTF,CPUSHF
  1661. X    COMMON /FINDEX/ BTIEF,BINFF
  1662. X    COMMON /FINDEX/ RVMNT,RVCLR,RVCYC,RVSND,RVGUA
  1663. X    COMMON /FINDEX/ ORRUG,ORCAND,ORMTCH,ORLAMP
  1664. X    COMMON /FINDEX/ MDIR,MLOC,POLEUF
  1665. X    COMMON /FINDEX/ QUESNO,NQATT,CORRCT
  1666. X    COMMON /FINDEX/ LCELL,PNUMB,ACELL,DCELL,CPHERE
  1667. X
  1668. X    LOGICAL FLAGS(46)
  1669. X    EQUIVALENCE (FLAGS(1),TROLLF)
  1670. X    INTEGER SWITCH(22)
  1671. X    EQUIVALENCE (SWITCH(1), BTIEF)
  1672. END_OF_flags.h
  1673. if test 1091 -ne `wc -c <flags.h`; then
  1674.     echo shar: \"flags.h\" unpacked with wrong size!
  1675. fi
  1676. # end of overwriting check
  1677. fi
  1678. if test -f gamestate.h -a "${1}" != "-c" ; then 
  1679.   echo shar: Will not over-write existing file \"gamestate.h\"
  1680. else
  1681. echo shar: Extracting \"gamestate.h\" \(67 characters\)
  1682. sed "s/^X//" >gamestate.h <<'END_OF_gamestate.h'
  1683. XC
  1684. XC GAME STATE
  1685. XC
  1686. X    LOGICAL TELFLG
  1687. X    COMMON /PLAY/ WINNER,HERE,TELFLG
  1688. END_OF_gamestate.h
  1689. if test 67 -ne `wc -c <gamestate.h`; then
  1690.     echo shar: \"gamestate.h\" unpacked with wrong size!
  1691. fi
  1692. # end of overwriting check
  1693. fi
  1694. if test -f io.h -a "${1}" != "-c" ; then 
  1695.   echo shar: Will not over-write existing file \"io.h\"
  1696. else
  1697. echo shar: Extracting \"io.h\" \(101 characters\)
  1698. sed "s/^X//" >io.h <<'END_OF_io.h'
  1699. XC
  1700. XC I/O VARIABLES
  1701. XC
  1702. X    CHARACTER INBUF(78)
  1703. X    COMMON /INPUT/ INLNT,INBUF
  1704. X    COMMON /CHAN/ INPCH,OUTCH,DBCH
  1705. END_OF_io.h
  1706. if test 101 -ne `wc -c <io.h`; then
  1707.     echo shar: \"io.h\" unpacked with wrong size!
  1708. fi
  1709. # end of overwriting check
  1710. fi
  1711. if test -f lightp.F -a "${1}" != "-c" ; then 
  1712.   echo shar: Will not over-write existing file \"lightp.F\"
  1713. else
  1714. echo shar: Extracting \"lightp.F\" \(2424 characters\)
  1715. sed "s/^X//" >lightp.F <<'END_OF_lightp.F'
  1716. XC LIGHTP-    LIGHT PROCESSOR
  1717. XC
  1718. XC COPYRIGHT 1980, INFOCOM COMPUTERS AND COMMUNICATIONS, CAMBRIDGE MA. 02142
  1719. XC ALL RIGHTS RESERVED, COMMERCIAL USAGE STRICTLY PROHIBITED
  1720. XC WRITTEN BY R. M. SUPNIK
  1721. XC
  1722. XC DECLARATIONS
  1723. XC
  1724. X    LOGICAL FUNCTION LIGHTP(OBJ)
  1725. X    IMPLICIT INTEGER (A-Z)
  1726. X    LOGICAL QON
  1727. X#include "parser.h"
  1728. X#include "gamestate.h"
  1729. X#include "objects.h"
  1730. X#include "oflags.h"
  1731. X#include "oindex.h"
  1732. X#include "clock.h"
  1733. X
  1734. X#include "verbs.h"
  1735. X#include "flags.h"
  1736. XC
  1737. XC FUNCTIONS AND DATA
  1738. XC
  1739. X    QON(R)=and(OFLAG1(R),ONBT).NE.0
  1740. XC LIGHTP, PAGE 2
  1741. XC
  1742. X    LIGHTP=.TRUE.
  1743. XC                        !ASSUME WINS
  1744. X    FLOBTS=FLAMBT+LITEBT+ONBT
  1745. X    IF(OBJ.NE.CANDL) GO TO 20000
  1746. XC                        !CANDLE?
  1747. X    IF(ORCAND.NE.0) GO TO 19100
  1748. XC                        !FIRST REF?
  1749. X    ORCAND=1
  1750. XC                        !YES, CANDLES ARE
  1751. X    CTICK(CEVCND)=50
  1752. XC                        !BURNING WHEN SEEN.
  1753. XC
  1754. X19100    IF(PRSI.EQ.CANDL) GO TO 10
  1755. XC                        !IGNORE IND REFS.
  1756. X    IF(PRSA.NE.TRNOFW) GO TO 19200
  1757. XC                        !TURN OFF?
  1758. X    I=513
  1759. XC                        !ASSUME OFF.
  1760. X    IF(QON(CANDL)) I=514
  1761. XC                        !IF ON, DIFFERENT.
  1762. X    CFLAG(CEVCND)=.FALSE.
  1763. XC                        !DISABLE COUNTDOWN.
  1764. X    OFLAG1(CANDL)=and(OFLAG1(CANDL), not(ONBT))
  1765. X    CALL RSPEAK(I)
  1766. X    RETURN
  1767. XC
  1768. X19200    IF((PRSA.NE.BURNW).AND.(PRSA.NE.TRNONW)) GO TO 10
  1769. X    IF(and(OFLAG1(CANDL),LITEBT).NE.0) GO TO 19300
  1770. X    CALL RSPEAK(515)
  1771. XC                        !CANDLES TOO SHORT.
  1772. X    RETURN
  1773. XC
  1774. X19300    IF(PRSI.NE.0) GO TO 19400
  1775. XC                        !ANY FLAME?
  1776. X    CALL RSPEAK(516)
  1777. XC                        !NO, LOSE.
  1778. X    PRSWON=.FALSE.
  1779. X    RETURN
  1780. XC
  1781. X19400    IF((PRSI.NE.MATCH).OR. .NOT.QON(MATCH)) GO TO 19500
  1782. X    I=517
  1783. XC                        !ASSUME OFF.
  1784. X    IF(QON(CANDL)) I=518
  1785. XC                        !IF ON, JOKE.
  1786. X    OFLAG1(CANDL)=or(OFLAG1(CANDL),ONBT)
  1787. X    CFLAG(CEVCND)=.TRUE.
  1788. XC                        !RESUME COUNTDOWN.
  1789. X    CALL RSPEAK(I)
  1790. X    RETURN
  1791. XC
  1792. X19500    IF((PRSI.NE.TORCH).OR. .NOT.QON(TORCH)) GO TO 19600
  1793. X    IF(QON(CANDL)) GO TO 19700
  1794. XC                        !ALREADY ON?
  1795. X    CALL NEWSTA(CANDL,521,0,0,0)
  1796. XC                        !NO, VAPORIZE.
  1797. X    RETURN
  1798. XC
  1799. X19600    CALL RSPEAK(519)
  1800. XC                        !CANT LIGHT WITH THAT.
  1801. X    RETURN
  1802. XC
  1803. X19700    CALL RSPEAK(520)
  1804. XC                        !ALREADY ON.
  1805. X    RETURN
  1806. XC
  1807. X20000    IF(OBJ.NE.MATCH) CALL BUG(6,OBJ)
  1808. X    IF((PRSA.NE.TRNONW).OR.(PRSO.NE.MATCH)) GO TO 20500
  1809. X    IF(ORMTCH.NE.0) GO TO 20100
  1810. XC                        !ANY MATCHES LEFT?
  1811. X    CALL RSPEAK(183)
  1812. XC                        !NO, LOSE.
  1813. X    RETURN
  1814. XC
  1815. X20100    ORMTCH=ORMTCH-1
  1816. XC                        !DECREMENT NO MATCHES.
  1817. X    OFLAG1(MATCH)=or(OFLAG1(MATCH),FLOBTS)
  1818. X    CTICK(CEVMAT)=2
  1819. XC                        !COUNTDOWN.
  1820. X    CALL RSPEAK(184)
  1821. X    RETURN
  1822. XC
  1823. X20500    IF((PRSA.NE.TRNOFW).OR.(and(OFLAG1(MATCH),ONBT).EQ.0))
  1824. X&        GO TO 10
  1825. X    OFLAG1(MATCH)=and(OFLAG1(MATCH), not(FLOBTS))
  1826. X    CTICK(CEVMAT)=0
  1827. X    CALL RSPEAK(185)
  1828. X    RETURN
  1829. XC
  1830. XC HERE FOR FALSE RETURN
  1831. XC
  1832. X10    LIGHTP=.FALSE.
  1833. X    RETURN
  1834. X    END
  1835. END_OF_lightp.F
  1836. if test 2424 -ne `wc -c <lightp.F`; then
  1837.     echo shar: \"lightp.F\" unpacked with wrong size!
  1838. fi
  1839. # end of overwriting check
  1840. fi
  1841. if test -f listen.c -a "${1}" != "-c" ; then 
  1842.   echo shar: Will not over-write existing file \"listen.c\"
  1843. else
  1844. echo shar: Extracting \"listen.c\" \(1090 characters\)
  1845. sed "s/^X//" >listen.c <<'END_OF_listen.c'
  1846. X#include <stdio.h>
  1847. X
  1848. X#ifndef CINDEXFILE
  1849. X#define CINDEXFILE    "/usr/games/lib/dunlib/dindx.dat"
  1850. X#endif
  1851. X
  1852. Xmain(numargs, argptr)
  1853. X
  1854. Xint numargs;
  1855. Xchar *argptr[];
  1856. X{
  1857. Xint  chr;
  1858. XFILE *fpin;
  1859. X
  1860. X
  1861. X    fprintf(stderr,"Yawn... \n");
  1862. X
  1863. X/*     open init file */
  1864. X    fpin = fopen(CINDEXFILE, "r");
  1865. X    if (fpin == NULL)  {
  1866. X        fclose(fpin);
  1867. X        fprintf(stderr,"Init file missing.\n");
  1868. X        exit(0);
  1869. X    }
  1870. X
  1871. X/*     transfer init file into the pipe */
  1872. X
  1873. X    while ((chr = getc(fpin)) != EOF)
  1874. X        putchar((char)chr);
  1875. X
  1876. X    fclose(fpin);
  1877. X
  1878. X/*    check for restore file argument  */
  1879. X
  1880. X    if(numargs > 1){
  1881. X        fpin = fopen(*++argptr,"r");
  1882. X        if( fpin == NULL)
  1883. X            fprintf(stderr,"Restore file missing.\n");
  1884. X        
  1885. X        else {
  1886. X            putchar('R');
  1887. X            while((chr = getc(fpin)) != EOF)
  1888. X                putchar((char)chr);
  1889. X            fprintf(stderr,"Now, where were we...\n");
  1890. X            fclose(fpin);
  1891. X        }
  1892. X    }
  1893. X
  1894. X    fprintf(stderr,"Oh hello .. \n");
  1895. X
  1896. X/*    send end of init data flag    */
  1897. X
  1898. X    putchar('?');
  1899. X    fflush(stdout);
  1900. X
  1901. X/*    send lines of standard input to pipe    */
  1902. X
  1903. X    while ((chr = getchar()) != EOF){
  1904. X        putchar(chr);
  1905. X        if (chr == '\n')
  1906. X            fflush(stdout);
  1907. X    }
  1908. X
  1909. X/*     end the process    */
  1910. X    fprintf(stderr,"Goodnight .. \n");
  1911. X}
  1912. END_OF_listen.c
  1913. if test 1090 -ne `wc -c <listen.c`; then
  1914.     echo shar: \"listen.c\" unpacked with wrong size!
  1915. fi
  1916. # end of overwriting check
  1917. fi
  1918. if test -f mindex.h -a "${1}" != "-c" ; then 
  1919.   echo shar: Will not over-write existing file \"mindex.h\"
  1920. else
  1921. echo shar: Extracting \"mindex.h\" \(52 characters\)
  1922. sed "s/^X//" >mindex.h <<'END_OF_mindex.h'
  1923. XC
  1924. XC MESSAGE INDEX
  1925. XC
  1926. X    COMMON /RMSG/ MLNT,RTEXT(1050)
  1927. END_OF_mindex.h
  1928. if test 52 -ne `wc -c <mindex.h`; then
  1929.     echo shar: \"mindex.h\" unpacked with wrong size!
  1930. fi
  1931. # end of overwriting check
  1932. fi
  1933. if test -f oindex.h -a "${1}" != "-c" ; then 
  1934.   echo shar: Will not over-write existing file \"oindex.h\"
  1935. else
  1936. echo shar: Extracting \"oindex.h\" \(1068 characters\)
  1937. sed "s/^X//" >oindex.h <<'END_OF_oindex.h'
  1938. XC
  1939. X    COMMON /OINDEX/ GARLI,FOOD,GUNK,COAL,MACHI,DIAMO,TCASE,BOTTL
  1940. X    COMMON /OINDEX/ WATER,ROPE,KNIFE,SWORD,LAMP,BLAMP,RUG
  1941. X    COMMON /OINDEX/    LEAVE,TROLL,AXE
  1942. X    COMMON /OINDEX/ RKNIF,KEYS,ICE,BAR
  1943. X    COMMON /OINDEX/ COFFI,TORCH,TBASK,FBASK,IRBOX
  1944. X    COMMON /OINDEX/ GHOST,TRUNK,BELL,BOOK,CANDL
  1945. X    COMMON /OINDEX/ MATCH,TUBE,PUTTY,WRENC,SCREW,CYCLO,CHALI
  1946. X    COMMON /OINDEX/ THIEF,STILL,WINDO,GRATE,DOOR
  1947. X    COMMON /OINDEX/ HPOLE,LEAK,RBUTT,RAILI
  1948. X    COMMON /OINDEX/ POT,STATU,IBOAT,DBOAT,PUMP,RBOAT
  1949. X    COMMON /OINDEX/ STICK,BUOY,SHOVE,BALLO,RECEP,GUANO
  1950. X    COMMON /OINDEX/ BROPE,HOOK1,HOOK2,SAFE,SSLOT,BRICK,FUSE
  1951. X    COMMON /OINDEX/ GNOME,BLABE,DBALL,TOMB
  1952. X    COMMON /OINDEX/ LCASE,CAGE,RCAGE,SPHER,SQBUT
  1953. X    COMMON /OINDEX/ FLASK,POOL,SAFFR,BUCKE,ECAKE,ORICE,RDICE,BLICE
  1954. X    COMMON /OINDEX/ ROBOT,FTREE,BILLS,PORTR,SCOL,ZGNOM
  1955. X    COMMON /OINDEX/ EGG,BEGG,BAUBL,CANAR,BCANA
  1956. X    COMMON /OINDEX/ YLWAL,RDWAL,PINDR,RBEAM
  1957. X    COMMON /OINDEX/ ODOOR,QDOOR,CDOOR,NUM1,NUM8
  1958. X    COMMON /OINDEX/ WARNI,CSLIT,GCARD,STLDR
  1959. X    COMMON /OINDEX/ HANDS,WALL,LUNGS,SAILO,AVIAT,TEETH
  1960. X    COMMON /OINDEX/ ITOBJ,EVERY,VALUA,OPLAY,WNORT,GWATE,MASTER
  1961. END_OF_oindex.h
  1962. if test 1068 -ne `wc -c <oindex.h`; then
  1963.     echo shar: \"oindex.h\" unpacked with wrong size!
  1964. fi
  1965. # end of overwriting check
  1966. fi
  1967. if test -f parser.h -a "${1}" != "-c" ; then 
  1968.   echo shar: Will not over-write existing file \"parser.h\"
  1969. else
  1970. echo shar: Extracting \"parser.h\" \(571 characters\)
  1971. sed "s/^X//" >parser.h <<'END_OF_parser.h'
  1972. XC
  1973. XC PARSER OUTPUT
  1974. XC
  1975. X    LOGICAL PRSWON
  1976. X    COMMON /PRSVEC/ PRSA,PRSI,PRSO,PRSWON,PRSCON
  1977. XC
  1978. XC PARSER STATE
  1979. XC
  1980. X    COMMON /ORPHS/ OFLAG,OACT,OSLOT,OPREP,ONAME
  1981. X    INTEGER ORP(5)
  1982. X    EQUIVALENCE (OFLAG, ORP)
  1983. XC
  1984. X    COMMON /LAST/ LASTIT
  1985. XC
  1986. X    COMMON /PV/ ACT,O1,O2,P1,P2
  1987. X    INTEGER OBJVEC(2),PRPVEC(2),PVEC(5)
  1988. X    EQUIVALENCE (OBJVEC(1),O1),(PRPVEC(1),P1),(PVEC,ACT)
  1989. XC
  1990. X    COMMON /SYNTAX/ VFLAG,DOBJ,DFL1,DFL2,DFW1,DFW2,
  1991. X&        IOBJ,IFL1,IFL2,IFW1,IFW2
  1992. X    INTEGER SYN(11)
  1993. X    EQUIVALENCE (VFLAG, SYN)
  1994. XC
  1995. X    COMMON /SYNFLG/ SDIR,SIND,SSTD,SFLIP,SDRIV,SVMASK
  1996. XC
  1997. X    COMMON /OBJFLG/ VABIT,VRBIT,VTBIT,VCBIT,VEBIT,VFBIT,VPMASK
  1998. END_OF_parser.h
  1999. if test 571 -ne `wc -c <parser.h`; then
  2000.     echo shar: \"parser.h\" unpacked with wrong size!
  2001. fi
  2002. # end of overwriting check
  2003. fi
  2004. if test -f puzzle.h -a "${1}" != "-c" ; then 
  2005.   echo shar: Will not over-write existing file \"puzzle.h\"
  2006. else
  2007. echo shar: Extracting \"puzzle.h\" \(68 characters\)
  2008. sed "s/^X//" >puzzle.h <<'END_OF_puzzle.h'
  2009. XC
  2010. XC PUZZLE ROOM STATE
  2011. XC
  2012. X    COMMON /PUZZLE/ CPDR(16),CPWL(8),CPVEC(64)
  2013. END_OF_puzzle.h
  2014. if test 68 -ne `wc -c <puzzle.h`; then
  2015.     echo shar: \"puzzle.h\" unpacked with wrong size!
  2016. fi
  2017. # end of overwriting check
  2018. fi
  2019. if test -f rflag.h -a "${1}" != "-c" ; then 
  2020.   echo shar: Will not over-write existing file \"rflag.h\"
  2021. else
  2022. echo shar: Extracting \"rflag.h\" \(97 characters\)
  2023. sed "s/^X//" >rflag.h <<'END_OF_rflag.h'
  2024. XC
  2025. X    COMMON /RFLAG/ RSEEN,RLIGHT,RLAND,RWATER,RAIR,
  2026. X&        RSACRD,RFILL,RMUNG,RBUCK,RHOUSE,RNWALL,REND
  2027. END_OF_rflag.h
  2028. if test 97 -ne `wc -c <rflag.h`; then
  2029.     echo shar: \"rflag.h\" unpacked with wrong size!
  2030. fi
  2031. # end of overwriting check
  2032. fi
  2033. if test -f rooms.h -a "${1}" != "-c" ; then 
  2034.   echo shar: Will not over-write existing file \"rooms.h\"
  2035. else
  2036. echo shar: Extracting \"rooms.h\" \(193 characters\)
  2037. sed "s/^X//" >rooms.h <<'END_OF_rooms.h'
  2038. XC
  2039. XC ROOMS
  2040. XC
  2041. X    COMMON /ROOMS/ RLNT,RDESC2,RDESC1(200),REXIT(200),
  2042. X&        RACTIO(200),RVAL(200),RFLAG(200)
  2043. X    INTEGER RRAND(200)
  2044. X    EQUIVALENCE (RVAL,RRAND)
  2045. X    INTEGER EQR(200,5)
  2046. X    EQUIVALENCE (RDESC1, EQR)
  2047. END_OF_rooms.h
  2048. if test 193 -ne `wc -c <rooms.h`; then
  2049.     echo shar: \"rooms.h\" unpacked with wrong size!
  2050. fi
  2051. # end of overwriting check
  2052. fi
  2053. if test -f rtim.c -a "${1}" != "-c" ; then 
  2054.   echo shar: Will not over-write existing file \"rtim.c\"
  2055. else
  2056. echo shar: Extracting \"rtim.c\" \(906 characters\)
  2057. sed "s/^X//" >rtim.c <<'END_OF_rtim.c'
  2058. X/*
  2059. X * Interface routines for dungeon.
  2060. X * These routines are for functions expected by the game
  2061. X * that are not available in the Unix/f77 library.
  2062. X */
  2063. X
  2064. X/* routine to get time in hours minutes and seconds */
  2065. X
  2066. X#include <sys/types.h>
  2067. X#include <sys/timeb.h>
  2068. X/* for V7 this should be <time.h> */
  2069. X#include <sys/time.h>
  2070. X
  2071. X
  2072. Xlong time();
  2073. Xstruct tm *localtime();
  2074. Xstruct tm *tmptr;
  2075. Xlong timebuf;
  2076. X
  2077. Xitime_(hrptr,minptr,secptr)
  2078. X
  2079. Xint *hrptr,*minptr,*secptr;
  2080. X{
  2081. X
  2082. X    time(&timebuf);
  2083. X    tmptr = localtime(&timebuf);
  2084. X    
  2085. X    *hrptr  = tmptr->tm_hour;
  2086. X    *minptr = tmptr->tm_min;
  2087. X    *secptr = tmptr->tm_sec;
  2088. X
  2089. X    return;
  2090. X}
  2091. X
  2092. X/* random number initializer */
  2093. Xinirnd_(seedptr)
  2094. X
  2095. Xint *seedptr;
  2096. X{
  2097. Xint seed;
  2098. X
  2099. X    seed = *seedptr;
  2100. X    srand(seed);
  2101. X    return;
  2102. X}
  2103. X
  2104. X/*  random number generator */
  2105. Xrnd_(maxval)
  2106. X
  2107. Xint *maxval;
  2108. X{
  2109. X/* note: returned random number ranges from 0 to maxval */
  2110. X
  2111. Xint rndval;
  2112. X
  2113. X    rndval = rand();
  2114. X
  2115. X    rndval = rndval % *maxval;
  2116. X
  2117. X    return(rndval);
  2118. X}
  2119. END_OF_rtim.c
  2120. if test 906 -ne `wc -c <rtim.c`; then
  2121.     echo shar: \"rtim.c\" unpacked with wrong size!
  2122. fi
  2123. # end of overwriting check
  2124. fi
  2125. if test -f screen.h -a "${1}" != "-c" ; then 
  2126.   echo shar: Will not over-write existing file \"screen.h\"
  2127. else
  2128. echo shar: Extracting \"screen.h\" \(98 characters\)
  2129. sed "s/^X//" >screen.h <<'END_OF_screen.h'
  2130. XC
  2131. XC SCREEN OF LIGHT
  2132. XC
  2133. X    COMMON /SCREEN/ FROMDR,SCOLRM,SCOLAC
  2134. X    COMMON /SCREEN/ SCOLDR(8),SCOLWL(12)
  2135. END_OF_screen.h
  2136. if test 98 -ne `wc -c <screen.h`; then
  2137.     echo shar: \"screen.h\" unpacked with wrong size!
  2138. fi
  2139. # end of overwriting check
  2140. fi
  2141. if test -f state.h -a "${1}" != "-c" ; then 
  2142.   echo shar: Will not over-write existing file \"state.h\"
  2143. else
  2144. echo shar: Extracting \"state.h\" \(90 characters\)
  2145. sed "s/^X//" >state.h <<'END_OF_state.h'
  2146. X    COMMON /STATE/ MOVES,DEATHS,RWSCOR,MXSCOR,MXLOAD,
  2147. X&        LTSHFT,BLOC,MUNGRM,HS,EGSCOR,EGMXSC
  2148. END_OF_state.h
  2149. if test 90 -ne `wc -c <state.h`; then
  2150.     echo shar: \"state.h\" unpacked with wrong size!
  2151. fi
  2152. # end of overwriting check
  2153. fi
  2154. if test -f villians.h -a "${1}" != "-c" ; then 
  2155.   echo shar: Will not over-write existing file \"villians.h\"
  2156. else
  2157. echo shar: Extracting \"villians.h\" \(222 characters\)
  2158. sed "s/^X//" >villians.h <<'END_OF_villians.h'
  2159. XC
  2160. XC VILLAINS AND DEMONS
  2161. XC
  2162. X    LOGICAL THFFLG,SWDACT,THFACT
  2163. X    COMMON /HACK/ THFPOS,THFFLG,THFACT,SWDACT,SWDSTA
  2164. XC
  2165. X    COMMON /VILL/ VLNT,VILLNS(4),VPROB(4),VOPPS(4),VBEST(4),VMELEE(4)
  2166. XC
  2167. X    INTEGER EQV(4,5)
  2168. X    EQUIVALENCE (VILLNS, EQV)
  2169. END_OF_villians.h
  2170. if test 222 -ne `wc -c <villians.h`; then
  2171.     echo shar: \"villians.h\" unpacked with wrong size!
  2172. fi
  2173. # end of overwriting check
  2174. fi
  2175. if test -f vocab.h -a "${1}" != "-c" ; then 
  2176.   echo shar: Will not over-write existing file \"vocab.h\"
  2177. else
  2178. echo shar: Extracting \"vocab.h\" \(556 characters\)
  2179. sed "s/^X//" >vocab.h <<'END_OF_vocab.h'
  2180. XC
  2181. XC VOCABULARIES
  2182. XC
  2183. X    COMMON /BUZVOC/ BVOC(20)
  2184. X    COMMON /PRPVOC/ PVOC(45)
  2185. X    COMMON /DIRVOC/ DVOC(75)
  2186. X    INTEGER AVOC(450)
  2187. X    COMMON /ADJVOC/ AVOC1(184),AVOC2(114),AVOC3(106),AVOCND
  2188. X    INTEGER VVOC(950)
  2189. X    COMMON /VRBVOC/ VVOC1(92),VVOC1A(108),VVOC1B(38),VVOC2(104),
  2190. X&        VVOC3(136),
  2191. X&        VVOC4(116),VVOC5(134),VVOC6(117),VVOC7(89),VVOCND
  2192. X    INTEGER OVOC(1050)
  2193. X    COMMON /OBJVOC/ OVOC1(159),OVOC2(144),OVOC3(150),OVOC4(128),
  2194. X&        OVOC5(111),OVOC6(104),OVOC6A(97),OVOC7(127),OVOCND
  2195. XC
  2196. X    EQUIVALENCE (VVOC(1),VVOC1(1))
  2197. X    EQUIVALENCE (AVOC(1),AVOC1(1))
  2198. X    EQUIVALENCE (OVOC(1),OVOC1(1))
  2199. END_OF_vocab.h
  2200. if test 556 -ne `wc -c <vocab.h`; then
  2201.     echo shar: \"vocab.h\" unpacked with wrong size!
  2202. fi
  2203. # end of overwriting check
  2204. fi
  2205. if test -f xpars.h -a "${1}" != "-c" ; then 
  2206.   echo shar: Will not over-write existing file \"xpars.h\"
  2207. else
  2208. echo shar: Extracting \"xpars.h\" \(95 characters\)
  2209. sed "s/^X//" >xpars.h <<'END_OF_xpars.h'
  2210. XC
  2211. X    COMMON /XPARS/ XRMASK,XDMASK,XFMASK,XFSHFT,XASHFT,
  2212. X&        XELNT(4),XNORM,XNO,XCOND,XDOOR,XLFLAG
  2213. END_OF_xpars.h
  2214. if test 95 -ne `wc -c <xpars.h`; then
  2215.     echo shar: \"xpars.h\" unpacked with wrong size!
  2216. fi
  2217. # end of overwriting check
  2218. fi
  2219. if test -f xsrch.h -a "${1}" != "-c" ; then 
  2220.   echo shar: Will not over-write existing file \"xsrch.h\"
  2221. else
  2222. echo shar: Extracting \"xsrch.h\" \(81 characters\)
  2223. sed "s/^X//" >xsrch.h <<'END_OF_xsrch.h'
  2224. XC
  2225. X    COMMON /XSRCH/ XMIN,XMAX,XDOWN,XUP,
  2226. X&        XNORTH,XSOUTH,XENTER,XEXIT,XEAST,XWEST
  2227. END_OF_xsrch.h
  2228. if test 81 -ne `wc -c <xsrch.h`; then
  2229.     echo shar: \"xsrch.h\" unpacked with wrong size!
  2230. fi
  2231. # end of overwriting check
  2232. fi
  2233. echo shar: End of archive 7 \(of 14\).
  2234. cp /dev/null ark7isdone
  2235. MISSING=""
  2236. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
  2237.     if test ! -f ark${I}isdone ; then
  2238.     MISSING="${MISSING} ${I}"
  2239.     fi
  2240. done
  2241. if test "${MISSING}" = "" ; then
  2242.     echo You have unpacked all 14 archives.
  2243.     rm -f ark[1-9]isdone ark1[1-9]isdone
  2244. else
  2245.     echo You still need to unpack the following archives:
  2246.     echo "        " ${MISSING}
  2247. fi
  2248. ##  End of shell archive.
  2249. exit 0
  2250.